sample.hh

Go to the documentation of this file.

/*****************************************************************
 *
 *   file:   sample.hh
 *   desc:   This file provides the C++ Sample declarations.
 *
 *****************************************************************
 *
 *   Copyright(C) 2006-2016 Twin Oaks Computing, Inc
 *   All rights reserved.   Castle Rock, CO 80108
 *
 *****************************************************************
 *
 *  This software has been provided pursuant to a License Agreement
 *  containing restrictions on its use.  This software contains
 *  valuable trade secrets and proprietary information of
 *  Twin Oaks Computing, Inc and is protected by law.  It may not be
 *  copied or distributed in any form or medium, disclosed to third
 *  parties, reverse engineered or used in any manner not provided
 *  for in said License Agreement except with the prior written
 *  authorization from Twin Oaks Computing, Inc. 
 *
 *****************************************************************/

#ifndef DDS_SAMPLE_HH
#define DDS_SAMPLE_HH

#include <string>
#include <stdexcept>
#include <memory>
#include <iterator>

#include <stdio.h>
#include <dds/dds.hh>

namespace DDS { 

  namespace details {

    template <bool, typename T, typename U>
    struct if_ {
      typedef T type;
    };

    template <typename T, typename U>
    struct if_ <false, T, U> {
      typedef U type;
    };

  } // namespace details

  template<typename T, bool> class SampleIterator;
  template<typename T>       class Sample;
  template<typename T>       class SampleRef;
  template<typename T>       class WriteSample;
  template<typename T>       class WriteSampleRef;
  template<class T>          class LoanedSamples;
  template<class T>          class SharedSamples;

  namespace rpc {
    template <typename TReq, typename TRep>    class Requester;
    template <typename TReq, typename TRep>    class Replier;
  }

  template <typename T> 
  struct dds_type_traits
  {
    typedef typename T::Seq               Seq;
    typedef const typename T::Seq         ConstSeq;
    typedef typename T::DataReader      * DataReader;
    typedef typename T::DataWriter      * DataWriter;

    typedef DDS::SampleRef<T>             SampleRefType;
    typedef DDS::SampleRef<T>             SampleIteratorValueType;
    typedef DDS::SampleRef<const T>       ConstSampleIteratorValueType;
    typedef DDS::LoanedSamples<T>         LoanedSamplesType;
    typedef DDS::SharedSamples<T>         SharedSamplesType;
    typedef DDS::SampleIterator<T, false> iterator;
    typedef DDS::SampleIterator<T, true>  const_iterator;
  };

  template <> 
  struct dds_type_traits<DDS::SampleInfo> 
  {
    typedef DDS::SampleInfoSeq            Seq; 
    typedef const DDS::SampleInfoSeq      ConstSeq;
  };

  struct dds_entity_traits; // defined in vendor_dependent.h

  // -------------------------------------------------------------------------
  // -------------------------------------------------------------------------
  template <typename T>
  class Sample 
  {
  public:
    typedef T                                             Data;
    typedef T&                                            DataReference;
    typedef const T&                                      ConstDataReference;
    typedef typename DDS::dds_type_traits<T>::Seq         Seq;
    typedef typename DDS::dds_type_traits<T>::DataReader  DataReader;
    typedef typename DDS::dds_type_traits<T>::DataWriter  DataWriter;

    Sample() :_data(NULL),_info(NULL) {}
    Sample(const Sample<T>& other);
    Sample(SampleRef<T> sample_ref);
    Sample(const T &data, const DDS::SampleInfo& info);
    ~Sample();

    DDS::SampleIdentity_t   identity() const;
    DDS::SampleIdentity_t   related_identity() const;
    void                    swap(Sample & other);
    T &                     data();
    DDS::SampleInfo &       info();
    const T &               data() const;
    const DDS::SampleInfo & info() const;

    void                    set_data(const T &t);
    void                    set_data(const T *t);
    void                    set_info(const DDS::SampleInfo &i);
    void                    set_info(const DDS::SampleInfo *i);

    Sample & operator = (Sample<T>    sample);
    Sample & operator = (SampleRef<T> sample_ref);
    operator DataReference ();
    operator ConstDataReference () const;

    friend class DDS::DataReader;
    friend class DDS::DataWriter;
    template <typename TReq, typename TRep> friend class DDS::rpc::Requester;
    template <typename TReq, typename TRep> friend class DDS::rpc::Replier;

  protected:
    T                    * _data;
    DDS::SampleInfo      * _info;
    DDS::SampleIdentity_t  _identity;
    DDS::SampleIdentity_t  _related_identity;
  };

  // -------------------------------------------------------------------------
  // -------------------------------------------------------------------------
  template <typename T>
  class SampleRef
  {
  public:
    typedef T                                             Data;
    typedef T&                                            DataReference;
    typedef const T&                                      ConstDataReference;
    typedef typename DDS::dds_type_traits<T>::Seq         Seq;
    typedef typename DDS::dds_type_traits<T>::DataReader  DataReader;
    typedef typename DDS::dds_type_traits<T>::DataWriter  DataWriter;

  public:
    SampleRef();
    SampleRef(T * data, DDS::SampleInfo * info);
    SampleRef(T & data, DDS::SampleInfo & info);
    SampleRef(Sample<T> & sample);

    SampleRef           & operator = (Sample<T> & sample);
    T                   & data() const;
    DDS::SampleInfo     & info() const;
    operator              T & () const;

    // this might be more useful, right? [ is the spec wrong ? ]
    // T                * operator ->();
    // const T          * operator ->() const;

    SampleRef<T>        * operator ->();
    const SampleRef<T>  * operator ->() const;

    void                  set_data(T * data);
    void                  set_data(T & data);
    void                  set_info(DDS::SampleInfo * info);
    void                  set_info(DDS::SampleInfo & info);
    bool                  is_nil_data() const;
    bool                  is_nil_info() const;
    void                  swap(SampleRef & other) throw();
    DDS::SampleIdentity_t identity() const;
    DDS::SampleIdentity_t related_identity() const;

    friend class DDS::DataReader;
    friend class DDS::DataWriter;
    template <typename TReq, typename TRep> friend class DDS::rpc::Requester;
    template <typename TReq, typename TRep> friend class DDS::rpc::Replier;
  protected:
    T                    * _data;
    DDS::SampleInfo      * _info;
    DDS::SampleIdentity_t  _identity;
    DDS::SampleIdentity_t  _related_identity;
  };

  // -------------------------------------------------------------------------
  // -------------------------------------------------------------------------
  template <typename T, bool IsConst>
  class SampleIterator 
  {
  public:
    typedef std::random_access_iterator_tag iterator_category;

    typedef typename details::if_<IsConst, 
                                  typename dds_type_traits<T>::ConstSampleIteratorValueType, 
                                  typename dds_type_traits<T>::SampleIteratorValueType>::type  value_type;
    
    typedef value_type reference;
    typedef value_type pointer;
    typedef std::ptrdiff_t difference_type;
    
    typedef typename details::if_<IsConst, 
                                  typename dds_type_traits<T>::ConstSeq, 
                                  typename dds_type_traits<T>::Seq>::type                      Seq;

    typedef typename details::if_<IsConst, 
                                  typename dds_type_traits<DDS::SampleInfo>::ConstSeq, 
                                  typename dds_type_traits<DDS::SampleInfo>::Seq>::type        InfoSeq;

    SampleIterator();
    explicit SampleIterator(Seq & seq, 
                            InfoSeq & info_seq, 
                            int position = 0);
    SampleIterator (const SampleIterator<T, false> & si);
    SampleIterator &              operator = (const SampleIterator<T, false> & si);
    value_type                    operator * () const;
    value_type                    operator ->() const;
    value_type                    operator [] (difference_type offset) const;
    SampleIterator              & operator ++ ();
    SampleIterator                operator ++ (int);
    SampleIterator              & operator -- ();
    SampleIterator                operator -- (int);
    SampleIterator              & operator -= (difference_type i);
    SampleIterator              & operator += (difference_type i);
    SampleIterator                operator - (difference_type i) const;
    SampleIterator                operator + (difference_type i) const;
    difference_type               operator - (const SampleIterator & s2) const;
    bool                          operator < (const SampleIterator & s2) const;
    bool                          operator > (const SampleIterator & s2) const;
    bool                          operator <= (const SampleIterator & s2) const;
    bool                          operator >= (const SampleIterator & s2) const;
    bool                          operator == (const SampleIterator & s2) const;
    bool                          operator != (const SampleIterator & s2) const;
    bool                          is_end() const;

  protected:
    uint32_t  _current;
    Seq     * _sample_seq;
    InfoSeq * _info_seq;
  };

  // -------------------------------------------------------------------------
  // -------------------------------------------------------------------------
  template <typename T>
  LoanedSamples<T> move(LoanedSamples<T> & ls) throw();

  // -------------------------------------------------------------------------
  // -------------------------------------------------------------------------
  // This class implements the move-constructor idiom as in DDS-PSM-Cxx
  template <typename T>
  class LoanedSamples
  {
  public:
    typedef typename dds_type_traits<T>::Seq                             Seq;
    typedef typename dds_type_traits<T>::DataReader                      DataReader;

    typedef SampleIterator<T, false>                                     iterator;
    typedef SampleIterator<T, true>                                      const_iterator;

    typedef typename dds_type_traits<T>::SampleIteratorValueType         value_type;
    typedef typename dds_type_traits<T>::ConstSampleIteratorValueType    const_value_type;
    typedef std::ptrdiff_t                                               difference_type;
  
  public:
    LoanedSamples();
    ~LoanedSamples() throw();

    static LoanedSamples<T>       move_construct_from_loans(DataReader reader, 
                                                            Seq & data_seq, 
                                                            DDS::SampleInfoSeq & info_seq);
    void                          release(DataReader         & reader_ptr, 
                                          Seq                & data_seq, 
                                          DDS::SampleInfoSeq & info_seq); 

#ifdef TOC_MOVE_SEMANTICS_AVAILABLE
    LoanedSamples(const LoanedSamples &) = delete;
    LoanedSamples(LoanedSamples &&) noexcept;
    LoanedSamples &               operator = (const LoanedSamples &) = delete;
    LoanedSamples &               operator = (LoanedSamples &&) noexcept;
#else
    struct LoanMemento 
    {
      DataReader            _reader;
      Seq                   _data_seq;
      DDS::SampleInfoSeq    _info_seq;
    };

    LoanedSamples(LoanedSamples &); // copy constructor (to force VS to enable RVO)
    
    LoanedSamples(LoanMemento loan_memento) throw();
    LoanedSamples &               operator = (LoanMemento loan_memento) throw();
    operator LoanMemento () throw();
    friend LoanedSamples          move<> (LoanedSamples &) throw();
#endif 

    Seq                         & data_seq(); 
    DDS::SampleInfoSeq          & info_seq(); 

    const Seq                   & data_seq() const;
    const DDS::SampleInfoSeq    & info_seq() const;

    value_type                    operator [] (size_t index);
    const_value_type              operator [] (size_t index) const;
    int                           length() const;
    int                           size() const { return this->length(); }
    void                          return_loan();
    void                          swap(LoanedSamples & that) throw();
    SharedSamples<T>              to_shared() throw();
    iterator                      begin();
    iterator                      end();
    const_iterator                begin() const;
    const_iterator                end() const;

  private:
    DataReader            _reader;
    Seq                   _data_seq;
    DDS::SampleInfoSeq    _info_seq;
    
#ifndef TOC_MOVE_SEMANTICS_AVAILABLE
    LoanedSamples &               operator = (LoanedSamples &);
#endif

  };

  // -------------------------------------------------------------------------
  // -------------------------------------------------------------------------
  template <typename T>
  class SharedSamples
  {
  public:
    typedef typename dds_type_traits<T>::Seq                             Seq;
    typedef typename dds_type_traits<T>::DataReader                      DataReader;

    typedef SampleIterator<T, false>                                     iterator;
    typedef SampleIterator<T, true>                                      const_iterator;

    typedef typename dds_type_traits<T>::SampleIteratorValueType         value_type;
    typedef typename dds_type_traits<T>::ConstSampleIteratorValueType    const_value_type;
    typedef std::ptrdiff_t                                               difference_type;

  public:
    SharedSamples();
    SharedSamples(const SharedSamples &);
    ~SharedSamples() throw();
    SharedSamples               & operator = (const SharedSamples &);
    Seq                         & data_seq(); 
    DDS::SampleInfoSeq          & info_seq(); 
    const Seq                   & data_seq() const;
    const DDS::SampleInfoSeq    & info_seq() const;
    value_type                    operator [] (size_t index);
    const_value_type              operator [] (size_t index) const;
    int                           length() const;
    void                          swap(SharedSamples & that) throw();
    iterator                      begin();
    iterator                      end();
    const_iterator                begin() const;
    const_iterator                end() const;

  private:
    Seq                 * _data_seq;
    DDS::SampleInfoSeq  * _info_seq;
  };

  // -------------------------------------------------------------------------
  // -------------------------------------------------------------------------
  template <typename T>
  class WriteSample  
  {

  public:
    WriteSample();
    WriteSample(const WriteSample<T>& other);
    WriteSample(const T & data);
    WriteSample(const WriteSampleRef<T> & wsref);
    ~WriteSample();

    WriteSample                 & operator = (const WriteSampleRef<T> & wsref);
    WriteSample                 & operator = (const WriteSample<T> & ws);

    const T                     & data() const;  // this can't allocate new 'T'
    T                           & data();
    void                          set_data(const T & data);
    void                          set_identity(const DDS::SampleIdentity_t & id);
    void                          swap(WriteSample & other) throw();
    DDS::SampleIdentity_t         identity() const;    

    friend class DDS::DataReader;
    friend class DDS::DataWriter;
    template <typename TReq, typename TRep> friend class DDS::rpc::Requester;
    template <typename TReq, typename TRep> friend class DDS::rpc::Replier;
  protected:
    T                * _data;
    SampleIdentity_t   _identity;
  };

  // -------------------------------------------------------------------------
  // -------------------------------------------------------------------------
  template <typename T>
  class WriteSampleRef
  { 
  public:
    WriteSampleRef();
    WriteSampleRef(T & data); // was "const data", but that doesn't seem like much of a 'Ref' 
    WriteSampleRef(WriteSample<T> & ws);
    WriteSampleRef(const WriteSampleRef<T> & wsref);
    WriteSampleRef              & operator = (WriteSample<T> & ws);
    WriteSampleRef              & operator = (const WriteSampleRef<T> & wsref);
    const T                     & data() const;
    T                           & data();
    void                          set_data(T & data); // was const T & data... but doesn't seem like a 'Ref'
    void                          set_identity(const DDS::SampleIdentity_t & id);
    void                          swap(WriteSampleRef & other) throw();
    DDS::SampleIdentity_t         identity() const;

    friend class DDS::DataReader;
    friend class DDS::DataWriter;
    template <typename TReq, typename TRep> friend class DDS::rpc::Requester;
    template <typename TReq, typename TRep> friend class DDS::rpc::Replier;
  protected:
    T                * _data;
    SampleIdentity_t   _identity;
  };
  

  // -------------------------------------------------------------------------
  // -------------------------------------------------------------------------

#ifdef TOC_MOVE_SEMANTICS_AVAILABLE
  template <typename T>
  LoanedSamples<T> move(LoanedSamples<T> & ls) noexcept 
  {
    return std::move(ls);
  }
#else
  template <typename T>
  LoanedSamples<T> move(LoanedSamples<T> & ls) throw()
  {
    return LoanedSamples<T>(typename LoanedSamples<T>::LoanMemento(ls));
  }
#endif

  template <typename T>
  typename LoanedSamples<T>::iterator begin(LoanedSamples<T> & ls)
  {
    return ls.begin();
  }

  template <typename T>
  typename LoanedSamples<T>::const_iterator begin(const LoanedSamples<T> & ls)
  {
    return ls.begin();
  }

  template <typename T>
  typename LoanedSamples<T>::iterator end(LoanedSamples<T> & ls)
  {
    return ls.end();
  }

  template <typename T>
  typename LoanedSamples<T>::const_iterator end(const LoanedSamples<T> & ls)
  {
    return ls.end();
  }

  template <typename T>
  void swap(LoanedSamples<T> &ls1, LoanedSamples<T> &ls2) throw()
  {
    ls1.swap(ls2);
  }

  template <typename T>
  typename SharedSamples<T>::iterator begin(SharedSamples<T> & ss)
  {
    return ss.begin();
  }

  template <typename T>
  typename SharedSamples<T>::const_iterator begin(const SharedSamples<T> & ss)
  {
    return ss.begin();
  }

  template <typename T>
  typename SharedSamples<T>::iterator end(SharedSamples<T> & ss)
  {
    return ss.end();
  }

  template <typename T>
  typename SharedSamples<T>::const_iterator end(const SharedSamples<T> & ss)
  {
    return ss.end();
  }

  template <typename T>
  void swap(SharedSamples<T> &ss1, SharedSamples<T> &ss2) throw()
  {
    ss1.swap(ss2);
  }



} // namespace dds 


#include <dds/sample_tmpl.hh>
#include <dds/sampleref_tmpl.hh>
#include <dds/sampleiterator_tmpl.hh>
#include <dds/loanedsamples_tmpl.hh>
#include <dds/sharedsamples_tmpl.hh>
#include <dds/writesample_tmpl.hh>
#include <dds/writesampleref_tmpl.hh>


#endif // DDS_SAMPLE_HH