idx_dev.h

Go to the documentation of this file.

#ifndef __utl_dev_idx_dev_h__
#define __utl_dev_idx_dev_h__

#include <utl/core/impl.h>
#include <utl/core/crtp.h>
#include <utl/dev/dev_iterators.h>
#include <utl/meta/meta.h>

namespace utl {


   template <typename impl_t, typename data_t, typename idx_t, size_t N>
   class idx_dev {
      _CRTP_IMPL(impl_t);
      using idx_dev_t = idx_dev <impl_t, data_t, idx_t, N>; 

   public:
      using data_type   = data_t;
      using pointer_type= data_t*;
      using idx_type    = idx_t;
      using type = idx_dev_t;    

   protected:
      ~idx_dev () = default;                    
      idx_dev () = default;                     
      idx_dev(const idx_dev_t&) = delete;                
      idx_dev_t& operator= (const idx_dev_t&) = delete;  

   private:
      size_t get_ (data_t& data, idx_t idx)           { return impl().get_(data, idx); }
      size_t get_ (data_t* data, size_t n, idx_t idx) { return impl().get_(data, n, idx); }
      size_t put_ (const data_t& data, idx_t idx)           { return impl().put_(data, idx); }
      size_t put_ (const data_t* data, size_t n, idx_t idx) { return impl().put_ (data, n, idx); }
      idx_t  cursor_ () const    { return impl().cursor_(); }
      void   cursor_ (idx_t idx) { impl().cursor_(idx); }

   public:
      size_t get (data_t& data, idx_t cursor) {
         return get_ (data, cursor);
      }

      size_t get (data_t* data, size_t n, idx_t cursor) {
         return get_ (data, n, cursor);
      }

      size_t put (const data_t& data, idx_t cursor) {
         return put_ (data, cursor);
      }

      size_t put (const data_t* data, size_t n, idx_t cursor) {
          return put_ (data, n, cursor);
       }

      idx_t cursor () const { return cursor_(); }
      idx_t cursor (idx_t idx) { return cursor_(idx); }


      template <typename _Dst_t>
      idx_dev_t& operator>> (_Dst_t& dst) {
         static_assert ((sizeof (_Dst_t)%sizeof(data_t) == 0),
                        "Target size must be a integer multiple of device's data size");
         get_ (reinterpret_cast<data_t*>(&dst), sizeof(_Dst_t)/sizeof(data_t), cursor_());
         return *this;
      }
      template <typename _Dst_t>
      idx_dev_t& operator>> (_Dst_t* dst) = delete;

      idx_dev_t& operator>> (data_t& dst) {
         get_ (dst, cursor_());
         return *this;
      }


      template <typename _Src_t>
      idx_dev_t& operator<< (_Src_t& src) {
         static_assert ((sizeof (_Src_t)%sizeof(data_t) == 0),
                        "Source size must be a integer multiple of device's data size");
         put_ (reinterpret_cast<data_t*>(&src), sizeof (_Src_t)/sizeof(data_t), cursor_());
         return *this;
      }
      template <typename _Src_t>
      idx_dev_t& operator<< (_Src_t* src) = delete;

      idx_dev_t& operator<< (const data_t& src) {
         put_ (src, cursor_());
         return *this;
      }

      data_t& operator[] (const idx_t idx) {
         iterator it(this, idx);
         return *it;
      }

   public:
      using iterator       = idxdev_it <idx_dev_t, data_t*, N>;         
      using const_iterator = idxdev_it <idx_dev_t, const data_t*, N>;   

      iterator        begin ()       noexcept { return       iterator(this, iterator::beg); }
      const_iterator  begin () const noexcept { return const_iterator(this, iterator::beg); }
      const_iterator cbegin () const noexcept { return const_iterator(this, iterator::beg); }
      iterator        end ()         noexcept { return       iterator(this, iterator::eos); }
      const_iterator  end ()   const noexcept { return const_iterator(this, iterator::eos); }
      const_iterator cend ()   const noexcept { return const_iterator(this, iterator::eos); }
   };


   template <typename data_t, typename idx_t, size_t N>
   class idx_dev <virtual_tag, data_t, idx_t, N> {
      using idx_dev_t = idx_dev <virtual_tag, data_t, idx_t, N>; 

   public:
      using data_type   = data_t;
      using pointer_type= data_t*;
      using idx_type    = idx_t;
      using type = idx_dev_t; 

   public:
      virtual ~idx_dev () = default;             
   protected:
      idx_dev () = default;                      
      idx_dev(const idx_dev_t&) = delete;                
      idx_dev_t& operator= (const idx_dev_t&) = delete;  

   private:
      virtual size_t get_ (data_t&, idx_t) =0;
      virtual size_t get_ (data_t*, size_t n, idx_t) =0;
      virtual size_t put_ (const data_t&, idx_t) =0;
      virtual size_t put_ (const data_t*, size_t n, idx_t) =0;
      virtual idx_t  cursor_ () const =0;
      virtual void   cursor_ (idx_t) =0;

   public:
      size_t get (data_t& data, idx_t cursor) {
         return get_ (data, cursor);
      }

      size_t get (data_t* data, size_t n, idx_t cursor) {
         return get_ (data, n, cursor);
      }

      size_t put (const data_t& data, idx_t cursor) {
         return put_ (data, cursor);
      }

      size_t put (const data_t* data, size_t n, idx_t cursor) {
          return put_ (data, n, cursor);
       }

      idx_t cursor () const { return cursor_(); }
      idx_t cursor (idx_t idx) { return cursor_(idx); }


      template <typename _Dst_t>
      idx_dev_t& operator>> (_Dst_t& dst) {
         static_assert ((sizeof (_Dst_t)%sizeof(data_t) == 0),
                        "Target size must be an integer multiple of device's data size");
         get_ (reinterpret_cast<data_t*>(&dst), sizeof(_Dst_t)/sizeof(data_t), cursor_());
         return *this;
      }
      template <typename _Dst_t>
      idx_dev_t& operator>> (_Dst_t* dst) = delete;

      idx_dev_t& operator>> (data_t& dst) {
         get_ (dst, cursor_());
         return *this;
      }


      template <typename _Src_t>
      idx_dev_t& operator<< (_Src_t& src) {
         static_assert ((sizeof (_Src_t)%sizeof(data_t) == 0),
                        "Source size must be an integer multiple of device's data size");
         put_ (reinterpret_cast<data_t*>(&src), sizeof (_Src_t)/sizeof(data_t), cursor_());
         return *this;
      }
      template <typename _Src_t>
      idx_dev_t& operator<< (_Src_t* src) = delete;

      idx_dev_t& operator<< (const data_t& src) {
         put_ (src, cursor_());
         return *this;
      }

      data_t& operator[] (const idx_t idx) {
         iterator it(this, idx);
         return *it;
      }

   public:
      using iterator       = idxdev_it <idx_dev_t, data_t*, N>;         
      using const_iterator = idxdev_it <idx_dev_t, const data_t*, N>;   

      iterator        begin ()       noexcept { return       iterator(this, iterator::beg); }
      const_iterator  begin () const noexcept { return const_iterator(this, iterator::beg); }
      const_iterator cbegin () const noexcept { return const_iterator(this, iterator::beg); }
      iterator        end ()         noexcept { return       iterator(this, iterator::eos); }
      const_iterator  end ()   const noexcept { return const_iterator(this, iterator::eos); }
      const_iterator cend ()   const noexcept { return const_iterator(this, iterator::eos); }
   };

   #if defined _utl_have_concepts
      template <typename _Tp>
      concept bool Idx_dev = requires (_Tp t, const _Tp ct, typename _Tp::data_type v) {
         // Object type
   //      requires std::is_default_constructible<_Tp>::value;
         requires !std::is_copy_constructible<_Tp>::value;
         requires !std::is_copy_assignable<_Tp>::value;
         // Methods
         {t.get(v, 0)} -> size_t;
         {t.get(&v, 1, 0)} -> size_t;
         {t.put(v, 0)} -> size_t;
         {t.put(&v, 1, 0)} -> size_t;
         // Operators
         t >> v;
         t << v;
         {t[typename _Tp::idx_type{}]} -> typename _Tp::data_type&;
         // Iterators
         requires idxdev_iterator_c<typename _Tp::iterator>;
         typename _Tp::const_iterator; //XXX: change to concept: is_idxdev_iterator<_Tp>
         //requires idxdev_iterator_c<typename _Tp::const_iterator>;
         { t.begin()}  -> typename _Tp::iterator;
   //      {ct.begin()}  -> typename _Tp::const_iterator;
   //      { t.cbegin()} -> typename _Tp::const_iterator;
         { t.end()}  -> typename _Tp::iterator;
   //      {ct.end()}  -> typename _Tp::const_iterator;
   //      { t.cend()} -> typename _Tp::const_iterator;
      };
   #else
      namespace idx_dev_details {
         using std::declval;

         // main api members
         template <class _Tp> using try_get1_t   = decltype (declval<_Tp>().get (declval<typename _Tp::data_type&>()));
         template <class _Tp> using try_get2_t   = decltype (declval<_Tp>().get (declval<typename _Tp::data_type*>(), declval<size_t>()));
         // operators
         //template <class _Tp> using try_extract_t= decltype (declval<_Tp>() >> declval<typename _Tp::data_type&>());
         // iterator members
         template <class _Tp> using try_begin_t  = decltype (declval<_Tp>().begin());
         template <class _Tp> using tryc_begin_t = decltype (declval<const _Tp>().begin());
         template <class _Tp> using try_cbegin_t = decltype (declval<const _Tp>().cbegin());
         template <class _Tp> using try_end_t    = decltype (declval<_Tp>().begin());
         template <class _Tp> using tryc_end_t   = decltype (declval<const _Tp>().begin());
         template <class _Tp> using try_cend_t   = decltype (declval<const _Tp>().cend());

         template <typename _Tp, typename =void>
         struct is_idx_dev_ : false_ {};

         template <typename _Tp>
         struct is_idx_dev_ <_Tp,
            void_t <
               typename _Tp::data_type,
               typename _Tp::pointer_type,
               typename _Tp::iterator,
               typename _Tp::const_iterator,
               use_if_same_t <try_get1_t <_Tp>,  size_t>,
               use_if_same_t <try_get2_t <_Tp>,  size_t>,
               //if_same_t <try_extract_t<_Tp>,typename _Tp&>,
               use_if_same_t <try_begin_t<_Tp>,  typename _Tp::iterator>,
               use_if_same_t <tryc_begin_t<_Tp>, typename _Tp::const_iterator>,
               use_if_same_t <try_cbegin_t<_Tp>, typename _Tp::const_iterator>,
               use_if_same_t <try_end_t<_Tp>,    typename _Tp::iterator>,
               use_if_same_t <tryc_end_t<_Tp>,   typename _Tp::const_iterator>,
               use_if_same_t <try_cend_t<_Tp>,   typename _Tp::const_iterator>
            >
         > : true_ {};
      }
      template <typename _Tp>
      constexpr bool Idx_dev = idx_dev_details::is_idx_dev_ <_Tp>::value;
   #endif

}

#endif /* #ifndef __utl_dev_idx_dev_h__ */