reference.hpp

#ifndef __CUV_REFERENCE_HPP__
#define __CUV_REFERENCE_HPP__

#include <boost/type_traits/is_convertible.hpp>
#include <boost/utility/enable_if.hpp>
#include <iostream>

#include "meta_programming.hpp"
#include "tags.hpp"

namespace cuv {

namespace detail {

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

template<class value_type>
value_type entry_get(const value_type* ptr, size_t idx, host_memory_space);

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

template<class value_type>
value_type entry_get(const value_type* ptr, size_t idx, dev_memory_space);

}

template<class T, class M>
class reference
{

public:

    typedef typename unconst<T>::type value_type; 
    typedef M memory_space_type; 
    typedef reference<T, M> my_type; 

    value_type* ptr; 

    operator value_type() const {
        return detail::entry_get(ptr, 0, memory_space_type());
    }

    void operator=(const value_type& v) {
        detail::entry_set(ptr, 0, v, memory_space_type());
    }

    template<class _T>
    typename boost::enable_if_c<boost::is_convertible<_T, value_type>::value>::type operator=(const _T& v) {
        detail::entry_set(ptr, 0, (value_type) v, memory_space_type());
    }

    reference& operator=(const reference& o) {
        if (&o == &(*this)) // operator & is overloaded and returns value_type*
            return *this;
        (*this) = (value_type) o;
        return *this;
    }

    template<class OM>
    reference& operator=(const reference<T, OM>& o) {
        (*this) = static_cast<T>(o);
        return *this;
    }

    const value_type* operator&() const {
        return ptr;
    }

    value_type* operator&() {
        return ptr;
    }

    reference(const T* p) :
            ptr(p) {
    }

    reference(T* p) :
            ptr(p) {
    }

    reference(value_type& p) :
            ptr(&p) {
    }

    reference(const value_type& p) :
            ptr(&p) {
    }

    my_type& operator+=(const value_type& v) {
        *this = (value_type) (*this) + v;
        return *this;
    }

    my_type& operator-=(const value_type& v) {
        *this = (value_type) (*this) - v;
        return *this;
    }

    my_type& operator*=(const value_type& v) {
        *this = (value_type) (*this) * v;
        return *this;
    }

    my_type& operator/=(const value_type& v) {
        *this = (value_type) (*this) / v;
        return *this;
    }

    value_type operator++(int) {
        value_type v = *this;
        *this = v + 1;
        return v;
    }

    value_type operator--(int) {
        value_type v = *this;
        *this = v - 1;
        return v;
    }

    value_type operator++() {
        value_type v = *this;
        *this = v + 1;
        return v + 1;
    }

    value_type operator--() {
        value_type v = *this;
        *this = v - 1;
        return v - 1;
    }

    bool operator==(const value_type& v) {
        return ((value_type) *this) == v;
    }

    bool operator<=(const value_type& v) {
        return ((value_type) *this) <= v;
    }

    bool operator<(const value_type& v) {
        return ((value_type) *this) < v;
    }

    bool operator>=(const value_type& v) {
        return ((value_type) *this) >= v;
    }

    bool operator>(const value_type& v) {
        return ((value_type) *this) > v;
    }
};

}

template<class T, class M>
std::ostream& operator<<(std::ostream& os, const cuv::reference<T, M>& reference);

#endif