/home/brandes/workspace/LAMA/src/lama/HostWriteAccess.hpp

Go to the documentation of this file.

#ifndef LAMA_HOSTWRITEACCESS_HPP_
#define LAMA_HOSTWRITEACCESS_HPP_

// for dll_import
#include <lama/config.hpp>

// base classes
#include <lama/WriteAccess.hpp>

// others
#include <lama/ContextFactory.hpp>

namespace lama
{

template<typename T>
class HostWriteAccess : public WriteAccess<T>
{
public:

    typedef T ValueType;

    HostWriteAccess( LAMAArray<ValueType>& array );

    HostWriteAccess( LAMAArray<ValueType>& array, const IndexType size, const bool keep );

    HostWriteAccess( LAMAArrayView<ValueType>& view, const bool keep = true );

    virtual ~HostWriteAccess();

    inline ValueType& operator[] (const IndexType i);

    inline operator ValueType*();

    void push_back(const ValueType val);

    using WriteAccess<ValueType>::size;

    using WriteAccess<ValueType>::resize;

    using WriteAccess<ValueType>::reserve;

protected:

    using WriteAccess<ValueType>::mData;
};

template<typename T>
class HostWriteOnlyAccess : public HostWriteAccess<T>
{
public:

    typedef T ValueType;

    HostWriteOnlyAccess( LAMAArray<ValueType>& array )

      : HostWriteAccess<ValueType>( array, false )

    {
    }

    HostWriteOnlyAccess( LAMAArray<ValueType>& array, const IndexType size )

      : HostWriteAccess<ValueType>( array, size, false )

    {
    }

    ~HostWriteOnlyAccess()
    {
    }
};

template<typename T>
HostWriteAccess<T>::HostWriteAccess( LAMAArray<ValueType>& array )
    : WriteAccess<T>( array, ContextFactory::getContext( Context::Host ) )
{
}

template<typename T>
HostWriteAccess<T>::HostWriteAccess( LAMAArray<ValueType>& array, const IndexType size, const bool keep )
    : WriteAccess<T>(array, ContextFactory::getContext( Context::Host ), size, keep)
{
}

template<typename T>
HostWriteAccess<T>::HostWriteAccess( LAMAArrayView<ValueType>& view, const bool keep /* = true */)
    : WriteAccess<T>(view, ContextFactory::getContext( Context::Host ), keep)
{
}

template<typename T>
HostWriteAccess<T>::~HostWriteAccess()
{
}

template<typename T>
T& HostWriteAccess<T>::operator[] ( const IndexType i )
{
    LAMA_ASSERT_ERROR( mData, "[" << i << "]: HostWriteAccess has already"
                       << " been released or has not been allocated." );

    return mData[i];
}

template<typename T>
inline HostWriteAccess<T>::operator ValueType*()
{
    return mData;
}

template<typename T>
void HostWriteAccess<T>::push_back( const ValueType val )
{
    const IndexType currentSize = size();
    resize( currentSize + 1 );
    mData[ currentSize ] = val;
}

}

#endif // LAMA_HOSTWRITEACCESS_HPP_