Line data    Source code

       1             : /*
       2             :  * Distributed under the OpenDDS License.
       3             :  * See: http://www.OpenDDS.org/license.html
       4             :  */
       5             : 
       6             : #ifndef OPENDDS_DCPS_SEQUENCEITERATOR_H
       7             : #define OPENDDS_DCPS_SEQUENCEITERATOR_H
       8             : 
       9             : #include "Util.h"
      10             : #include "dds/Versioned_Namespace.h"
      11             : 
      12             : #include "tao/Unbounded_Value_Sequence_T.h"
      13             : #include <iterator>
      14             : 
      15             : OPENDDS_BEGIN_VERSIONED_NAMESPACE_DECL
      16             : 
      17             : namespace OpenDDS {
      18             : namespace DCPS {
      19             : 
      20             : template <typename Sequence>
      21             : class SequenceBackInsertIterator {
      22             : public:
      23             : 
      24             :   typedef std::output_iterator_tag iterator_category;
      25             :   typedef void value_type;
      26             :   typedef void difference_type;
      27             :   typedef void pointer;
      28             :   typedef void reference;
      29             : 
      30         363 :   explicit SequenceBackInsertIterator(Sequence& seq) : seq_(&seq) {}
      31             : 
      32         567 :   SequenceBackInsertIterator& operator=(const typename Sequence::value_type& value)
      33             :   {
      34         567 :     push_back(*seq_, value);
      35         567 :     return *this;
      36             :   }
      37             : 
      38         567 :   SequenceBackInsertIterator& operator*() { return *this; }
      39             : 
      40             :   SequenceBackInsertIterator& operator++() { return *this; }
      41             : 
      42             :   SequenceBackInsertIterator operator++(int) { return *this; }
      43             : 
      44             : private:
      45             :   Sequence* seq_;
      46             : };
      47             : 
      48             : template <typename Sequence>
      49           1 : inline SequenceBackInsertIterator<Sequence> back_inserter(Sequence& seq)
      50             : {
      51           1 :   return SequenceBackInsertIterator<Sequence>(seq);
      52             : }
      53             : 
      54             : template <typename Sequence_>
      55             : struct SequenceIterTraits
      56             : {
      57             :   typedef Sequence_ Sequence;
      58             :   typedef typename Sequence::value_type value_type;
      59             :   typedef typename Sequence::value_type* pointer;
      60             :   typedef typename Sequence::value_type& reference;
      61             : };
      62             : 
      63             : template <typename Sequence_>
      64             : struct ConstSequenceIterTraits
      65             : {
      66             :   typedef const Sequence_ Sequence;
      67             :   typedef const typename Sequence::value_type value_type;
      68             :   typedef const typename Sequence::value_type* pointer;
      69             :   typedef const typename Sequence::value_type& reference;
      70             : };
      71             : 
      72             : template <typename Derived, typename IterTraits>
      73             : struct SequenceIteratorBase
      74             : {
      75             :   typedef std::random_access_iterator_tag iterator_category;
      76             :   typedef int difference_type;
      77             :   typedef typename IterTraits::value_type value_type;
      78             :   typedef typename IterTraits::pointer pointer;
      79             :   typedef typename IterTraits::reference reference;
      80             : 
      81         475 :   Derived& as_derived() { return *static_cast<Derived*>(this); }
      82             : 
      83         303 :   const Derived& as_derived() const { return *static_cast<const Derived*>(this); }
      84             : 
      85             :   SequenceIteratorBase() : seq_(), current_(0) {}
      86             : 
      87         382 :   explicit SequenceIteratorBase(typename IterTraits::Sequence& sequence) : seq_(&sequence), current_(0) {}
      88             : 
      89         303 :   operator difference_type() const { return current_; }
      90             : 
      91             :   // Forward iterator requirements
      92             : 
      93         665 :   reference operator*() const { return (*seq_)[current_]; }
      94             : 
      95         190 :   pointer operator->() const { return &(*seq_)[current_]; }
      96             : 
      97         475 :   Derived& operator++()
      98             :   {
      99         475 :     ++current_;
     100         475 :     return as_derived();
     101             :   }
     102             : 
     103             :   Derived operator++(int)
     104             :   {
     105             :     Derived iter(as_derived());
     106             :     ++current_;
     107             :     return iter;
     108             :   }
     109             : 
     110         191 :   bool operator==(const Derived& rhs) const
     111             :   {
     112         191 :     return (seq_ == rhs.seq_) && (current_ == rhs.current_);
     113             :   }
     114             : 
     115         191 :   bool operator!=(const Derived& rhs) const { return !(*this == rhs); }
     116             : 
     117             :   // Bidirectional iterator requirements
     118             : 
     119             :   Derived& operator--()
     120             :   {
     121             :     --current_;
     122             :     return as_derived();
     123             :   }
     124             : 
     125             :   Derived operator--(int)
     126             :   {
     127             :     Derived iter(as_derived());
     128             :     --current_;
     129             :     return iter;
     130             :   }
     131             : 
     132             :   // Random-access iterator requirements
     133             : 
     134             :   reference operator[](difference_type n) const { return (*seq_)[n]; }
     135             : 
     136             :   Derived& operator+=(difference_type n)
     137             :   {
     138             :     current_ += n;
     139             :     return as_derived();
     140             :   }
     141             : 
     142             :   Derived operator+(difference_type n) const
     143             :   {
     144             :     Derived iter(as_derived());
     145             :     iter.current_ += n;
     146             :     return iter;
     147             :   }
     148             : 
     149             :   Derived& operator-=(difference_type n)
     150             :   {
     151             :     current_ -= n;
     152             :     return as_derived();
     153             :   }
     154             : 
     155             :   Derived operator-(difference_type n) const
     156             :   {
     157             :     Derived iter(as_derived());
     158             :     iter.current_ -= n;
     159             :     return iter;
     160             :   }
     161             : 
     162             :   Derived& operator+=(const Derived& rhs)
     163             :   {
     164             :     current_ += rhs.current_;
     165             :     return *this;
     166             :   }
     167             : 
     168             :   Derived operator+(const Derived& rhs) const
     169             :   {
     170             :     Derived iter(*this);
     171             :     iter.current_ += rhs.current_;
     172             :     return iter;
     173             :   }
     174             : 
     175             :   Derived& operator-=(const Derived& rhs)
     176             :   {
     177             :     current_ -= rhs.current_;
     178             :     return as_derived();
     179             :   }
     180             : 
     181         303 :   Derived operator-(const Derived& rhs) const
     182             :   {
     183         303 :     Derived iter(as_derived());
     184         303 :     iter.current_ -= rhs.current_;
     185         303 :     return iter;
     186             :   }
     187             : 
     188             :   bool operator<(const Derived& rhs) const
     189             :   {
     190             :     return current_ < rhs.current_;
     191             :   }
     192             : 
     193             :   bool operator>(const Derived& rhs) const
     194             :   {
     195             :     return current_ > rhs.current_;
     196             :   }
     197             : 
     198             :   bool operator<=(const Derived& rhs) const
     199             :   {
     200             :     return current_ <= rhs.current_;
     201             :   }
     202             : 
     203             :   bool operator>=(const Derived& rhs) const
     204             :   {
     205             :     return current_ >= rhs.current_;
     206             :   }
     207             : 
     208         191 :   static Derived begin(typename IterTraits::Sequence& sequence)
     209             :   {
     210         191 :     Derived iter(sequence);
     211         191 :     iter.current_ = 0;
     212         191 :     return iter;
     213             :   }
     214             : 
     215         191 :   static Derived end(typename IterTraits::Sequence& sequence)
     216             :   {
     217         191 :     Derived iter(sequence);
     218         191 :     iter.current_ = sequence.length();
     219         191 :     return iter;
     220             :   }
     221             : 
     222             : protected:
     223             :   typename IterTraits::Sequence* seq_;
     224             :   difference_type current_;
     225             : };
     226             : 
     227             : template <typename Sequence>
     228             : struct SequenceIterator : public SequenceIteratorBase<SequenceIterator<Sequence>,
     229             :                                                       SequenceIterTraits<Sequence> >
     230             : {
     231             :   typedef SequenceIteratorBase<SequenceIterator<Sequence>,
     232             :                                SequenceIterTraits<Sequence> > Base;
     233             : 
     234             :   SequenceIterator() : Base() {}
     235             :   explicit SequenceIterator(typename SequenceIterTraits<Sequence>::Sequence& seq) : Base(seq) {}
     236             : };
     237             : 
     238             : template <typename Sequence>
     239             : struct ConstSequenceIterator : public SequenceIteratorBase<ConstSequenceIterator<Sequence>,
     240             :                                                            ConstSequenceIterTraits<Sequence> >
     241             : {
     242             :   typedef SequenceIteratorBase<ConstSequenceIterator<Sequence>,
     243             :                                ConstSequenceIterTraits<Sequence> > Base;
     244             : 
     245             :   ConstSequenceIterator() : Base() {}
     246         382 :   explicit ConstSequenceIterator(typename ConstSequenceIterTraits<Sequence>::Sequence& seq) : Base(seq) {}
     247             : };
     248             : 
     249             : template <typename Sequence>
     250             : inline SequenceIterator<Sequence> sequence_begin(Sequence& seq)
     251             : {
     252             :   return SequenceIterator<Sequence>::Base::begin(seq);
     253             : }
     254             : 
     255             : template <typename Sequence>
     256             : inline SequenceIterator<Sequence> sequence_end(Sequence& seq)
     257             : {
     258             :   return SequenceIterator<Sequence>::Base::end(seq);
     259             : }
     260             : 
     261             : template <typename Sequence>
     262         191 : inline ConstSequenceIterator<Sequence> const_sequence_begin(Sequence& seq)
     263             : {
     264         191 :   return ConstSequenceIterator<Sequence>::Base::begin(seq);
     265             : }
     266             : 
     267             : template <typename Sequence>
     268         191 : inline ConstSequenceIterator<Sequence> const_sequence_end(Sequence& seq)
     269             : {
     270         191 :   return ConstSequenceIterator<Sequence>::Base::end(seq);
     271             : }
     272             : 
     273             : }  // namespace DCPS
     274             : }  // namespace OpenDDS
     275             : 
     276             : OPENDDS_END_VERSIONED_NAMESPACE_DECL
     277             : 
     278             : #endif