out_dev.h

Go to the documentation of this file.

#ifndef __utl_dev_out_dev_h__
#define __utl_dev_out_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, size_t streamsize =0>
   class out_dev {
      _CRTP_IMPL(impl_t);
      using out_dev_t = out_dev <impl_t, data_t, streamsize>;  

   public:
      using data_type      = data_t;
      using pointer_type   = data_t*;
      using type = out_dev_t;    

   protected:
      ~out_dev () = default;                     
      out_dev () = default;                      
      out_dev(const out_dev_t&) = delete;                
      out_dev_t& operator= (const out_dev_t&) = delete;  

   private:
      size_t put_ (const data_t& data) { return impl().put_ (data); }
      size_t put_ (const data_t* data, size_t n) {
         return impl().put_ (data, n);
      }

   public:
      size_t put (const data_t& data) {
         return put_ (data);
      }

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

   public:
       template <typename _Src_t>
       out_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));
          return *this;
       }
       template <typename _Src_t>
       out_dev_t& operator<< (_Src_t* src) = delete;

       out_dev_t& operator<< (const data_t& src) {
          put_ (src);
          return *this;
       }

      using iterator       = outdev_it <out_dev_t, data_t*, streamsize>;       
      using const_iterator = outdev_it <const out_dev_t, data_t*, streamsize>; 

      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, size_t streamsize>
   class out_dev <virtual_tag, data_t, streamsize> {
      using out_dev_t = out_dev <virtual_tag, data_t, streamsize>;   

   public:
      using data_type      = data_t;
      using pointer_type   = data_t*;
      using type = out_dev_t;  

   public:
      virtual ~out_dev () = default;         
   protected:
      out_dev () = default;                  
      out_dev(const out_dev&) = delete;      
      out_dev_t& operator= (const out_dev_t&) = delete;  

   private:
      virtual size_t put_ (const data_t& data) = 0;

      virtual size_t put_ (const data_t* data, size_t n) = 0;

   public:
      size_t put (const data_t& data) { return put_ (data); }
      size_t put (const data_t* data, size_t n) { return put_ (data, n); }

   public:
      template <typename _Src_t>
      out_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));
         return *this;
      }
      template <typename _Src_t>
      out_dev_t& operator<< (_Src_t* src) = delete;

      out_dev_t& operator<< (const data_t& src) {
         put_ (src);
         return *this;
      }

      using iterator       = outdev_it <out_dev_t, data_t*, streamsize>;       
      using const_iterator = outdev_it <const out_dev_t, data_t*, streamsize>; 

      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 Out_dev = requires (_Tp t, const _Tp ct, typename _Tp::data_type v) {
         // Object type
         requires !std::is_copy_constructible<_Tp>::value;
         requires !std::is_copy_assignable<_Tp>::value;
         // Methods
         {t.put(v)}              -> size_t;
         {t.put(&v, sizeof(v))}  -> size_t;
         // Operators
         t << v;
         // Iterators
         typename _Tp::const_iterator;
         requires Outdev_it<typename _Tp::iterator>;
         requires Outdev_it<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 out_dev_details {
      using std::declval;

      template <class _Tp> using try_put1_t = decltype (declval<_Tp>().put (declval<const typename _Tp::data_type&>()));
      template <class _Tp> using try_put2_t = decltype (declval<_Tp>().put (declval<const typename _Tp::data_type*>(),
                                                                            declval<size_t>()));
      // operators
      //template <class _Tp> using try_insert_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_out_dev_ : false_ { };

      template <typename _Tp>
      struct is_out_dev_ <_Tp,
         void_t <
            typename _Tp::data_type,
            typename _Tp::pointer_type,
            typename _Tp::iterator,
            typename _Tp::const_iterator,
            use_if_same_t <try_put1_t <_Tp>, size_t>,
            use_if_same_t <try_put2_t <_Tp>, size_t>,
            //if_same_t <try_insert_t<_Tp>,_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 Out_dev = out_dev_details::is_out_dev_<_Tp>::value;
   #endif

} //namespace utl

#endif /* #ifndef __utl_dev_out_dev_h__ */