accessors.hpp

#ifndef __ACCCESSORS_HPP__
#define __ACCCESSORS_HPP__
#include <cstring>
#include <cuv/tools/cuv_general.hpp>

namespace cuv
{
        template <class value_type, class size_type, class memory_space_type>
                struct allocator{
                        void alloc( value_type** ptr, size_type memsize)const; 
                        void alloc2d( value_type** ptr, size_type& pitch, size_type height, size_type width)const; 
                        void dealloc( value_type** ptr)const;                   

                        void copy(value_type* dst, const value_type*src,size_type size, host_memory_space); 

                        template<class value_type2>
                        void copy(value_type* dst, const value_type2*src,size_type size, dev_memory_space); 

                        void copy2d(value_type* dst, const value_type*src,size_type dpitch, size_type spitch, size_type h, size_type w, host_memory_space); 
                        void copy2d(value_type* dst, const value_type*src,size_type dpitch, size_type spitch, size_type h, size_type w, dev_memory_space);  

                        void alloc( const value_type** ptr, size_type memsize)const;   
                        void dealloc( const value_type** ptr)const;                     
                        void copy(const value_type* dst, const value_type*src,size_type size, host_memory_space)const{cuvAssert(false);}   
                        void copy(const value_type* dst, const value_type*src,size_type size, dev_memory_space)const{cuvAssert(false);};   
                };

    namespace detail
    {

        template <class value_type, class size_type>
                void entry_set(value_type* ptr, size_type idx, value_type val, host_memory_space);
        template <class value_type, class size_type>
                value_type entry_get(const value_type* ptr, size_type idx, host_memory_space);

        template <class value_type, class size_type>
                void entry_set(value_type* ptr, size_type idx, value_type val, dev_memory_space);
        template <class value_type, class size_type>
                value_type entry_get(const value_type* ptr, size_type idx, dev_memory_space);


        template <class value_type, class size_type>
                void entry_set(value_type* ptr, size_type idx, value_type val, host_memory_space) {
                        ptr[idx]=val;
                }


        template <class value_type, class size_type>
                value_type entry_get(const value_type* ptr, size_type idx, host_memory_space) {
                        return ptr[idx];
                }

    }

        template<class value_type, class size_type>
                struct allocator<value_type,size_type,host_memory_space>{
                        void alloc( value_type** ptr, size_type size) const;
                        void alloc2d( value_type** ptr, size_type& pitch, size_type height, size_type width)const; 

                        void dealloc( value_type** ptr)const ;
                        void alloc(const value_type** ptr, size_type size) const{
                                cuvAssert(false);
                        }
                        void dealloc(const value_type** ptr)const {
                                cuvAssert(false);
                        }
                        void copy(value_type* dst, const value_type*src,size_type size, host_memory_space){
                std::memcpy(dst,src,size*sizeof(value_type));
                        }
                        template<class value_type2>
                        void copy(value_type* dst, const value_type2*src,size_type size, host_memory_space){
                                for(unsigned int i=0;i<size;i++)
                                        dst[i] = (value_type)src[i];
                        }
                        void copy(value_type* dst, const value_type*src,size_type size, dev_memory_space);

                        void copy(const value_type* dst, const value_type*src,size_type size, host_memory_space)const{
                                cuvAssert(false);
                        }
                        void copy(const value_type* dst, const value_type*src,size_type size, dev_memory_space)const{
                                cuvAssert(false);
                        }

                        void copy2d(value_type* dst, const value_type*src,size_type dpitch, size_type spitch, size_type h, size_type w, host_memory_space); 
                        void copy2d(value_type* dst, const value_type*src,size_type dpitch, size_type spitch, size_type h, size_type w, dev_memory_space);  
                };
}


#endif /* __ACCCESSORS_HPP__ */