Added iterators

1 files changed, 938 insertions, 12 deletions

diff --git a/TAO/tao/Bounded_Basic_String_Sequence_T.h b/TAO/tao/Bounded_Basic_String_Sequence_T.h
index e43c34f539f..8cddf632593 100644
--- a/TAO/tao/Bounded_Basic_String_Sequence_T.h
+++ b/TAO/tao/Bounded_Basic_String_Sequence_T.h
@@ -19,6 +19,24 @@ TAO_BEGIN_VERSIONED_NAMESPACE_DECL
 
 namespace TAO
 {
+
+#if TAO_HAS_SEQUENCE_ITERATORS
+
+// Forward declare the iterators
+template<typename T>
+class BBS_Sequence_Iterator;
+
+template<typename T>
+class Const_BBS_Sequence_Iterator;
+
+template<typename T>
+class BBS_Sequence_Reverse_Iterator;
+
+template<typename T>
+class Const_BBS_Sequence_Reverse_Iterator;
+  
+#endif /* TAO_HAS_SEQUENCE_ITERATORS */
+
 template<typename charT, CORBA::ULong MAX>
 class bounded_basic_string_sequence
 {
@@ -113,59 +131,65 @@ public:
   ///
 
   // = Traits and factory methods that create iterators.
-  typedef details::Generic_Sequence_Iterator<details::generic_sequence<value_type, allocation_traits, element_traits> > iterator;
-  typedef details::Const_Generic_Sequence_Iterator<details::generic_sequence<value_type, allocation_traits, element_traits> > const_iterator;
-  typedef details::Generic_Sequence_Reverse_Iterator<details::generic_sequence<value_type, allocation_traits, element_traits> > reverse_iterator;
-  typedef details::Const_Generic_Sequence_Reverse_Iterator<details::generic_sequence<value_type, allocation_traits, element_traits> > const_reverse_iterator;
+  typedef BBS_Sequence_Iterator<bounded_basic_string_sequence<charT, MAX> > iterator;
+  typedef Const_BBS_Sequence_Iterator<bounded_basic_string_sequence<charT, MAX> > const_iterator;
+  typedef BBS_Sequence_Reverse_Iterator<bounded_basic_string_sequence<charT, MAX> > reverse_iterator;
+  typedef Const_BBS_Sequence_Reverse_Iterator<bounded_basic_string_sequence<charT, MAX> > const_reverse_iterator;
 
   // Get an iterator that points to the beginning of the sequence.
   iterator begin (void)
   {
-    return impl_.begin ();
+    return iterator (&this->impl_);
   }
 
   // Get a const iterator that points to the beginning of the sequence.
   const_iterator begin (void) const
   {
-    return impl_.begin ();
+    return const_iterator (&this->impl_);
   }
 
   // Get an iterator that points to the end of the sequence.
   iterator end (void)
   {
-    return impl_.end ();
+    return iterator (&this->impl_,
+                     this->impl_.length ());
   }
 
   // Get a const iterator that points to the end of the sequence.
   const_iterator end (void) const
   {
-    return impl_.end ();
+    return const_iterator (&this->impl_,
+                           this->impl_.length ());
   }
 
   // Get a reverse iterator that points to the end of the sequence.
   reverse_iterator rbegin (void)
   {
-    return impl_.rbegin ();
+    return reverse_iterator (&this->impl_,
+                             this->impl_.length () - 1);
   }
 
   // Get a const reverse iterator that points to the end of the sequence.
   const_reverse_iterator rbegin (void) const
   {
-    return impl_.rbegin ();
+    return const_reverse_iterator (&this->impl_,
+                                   this->impl_.length () - 1);
   }
 
   // Get a reverse iterator that points to one before the beginning
   // of the sequence.
   reverse_iterator rend (void)
   {
-    return impl_.rend ();
+    return reverse_iterator (&this->impl_,
+                             -1);
   }
 
   // Get a const reverse iterator that points to one before the
   // beginning of the sequence.
   const_reverse_iterator rend (void) const
   {
-    return impl_.rend ();
+    return const_reverse_iterator (&this->impl_,
+                                   -1);
   }
 
 #endif /* TAO_HAS_SEQUENCE_ITERATORS */
@@ -173,6 +197,908 @@ public:
 private:
   implementation_type impl_;
 };
+
+
+/**
+ * @class BBS_Sequence_Iterator
+ * @brief Implements a random access iterator for generic sequence type classes.
+ */
+template <typename SEQUENCE_T>
+  class BBS_Sequence_Iterator
+{
+  friend class Const_BBS_Sequence_Iterator<SEQUENCE_T>;
+
+public:
+  // = Necessary traits
+  typedef std::random_access_iterator_tag iterator_category;
+  typedef typename SEQUENCE_T::value_type value_type;
+  typedef typename SEQUENCE_T::value_type *pointer;
+  typedef typename SEQUENCE_T::value_type &reference;
+  typedef typename SEQUENCE_T::element_type element_type;
+  typedef typename SEQUENCE_T::const_element_type const_element_type;
+  typedef typename SEQUENCE_T::allocation_traits allocation_traits;
+  typedef typename SEQUENCE_T::element_traits element_traits;
+  typedef typename SEQUENCE_T::implementation_type implementation_type;
+  typedef CORBA::Long difference_type;
+
+  /// Construct a BBS_Sequence_Iterator at position pos.
+  BBS_Sequence_Iterator (implementation_type *sequence, 
+			 size_t pos = 0)
+    : sequence_ (sequence),
+    pos_ (pos)
+      {
+      }
+
+  /// Copy constructor
+  BBS_Sequence_Iterator (BBS_Sequence_Iterator<SEQUENCE_T> const & rhs)
+    : sequence_ (rhs.sequence_),
+    pos_ (rhs.pos_)
+      {
+      }
+  
+  /// Assignment operator
+  BBS_Sequence_Iterator & operator= (BBS_Sequence_Iterator<SEQUENCE_T> const & rhs)
+    {
+      BBS_Sequence_Iterator tmp(rhs);
+      swap (tmp);
+      return * this;
+    }
+
+  /// swaps all members
+  void swap(BBS_Sequence_Iterator<SEQUENCE_T> & rhs) 
+    throw()
+    {
+      std::swap (sequence_, rhs.sequence_);
+      std::swap (this->pos_, rhs.pos_);
+    }
+
+  /// typecast operator to Const_BBS_Sequence_Iterator
+  operator Const_BBS_Sequence_Iterator<SEQUENCE_T> ()
+  {
+    return Const_BBS_Sequence_Iterator<SEQUENCE_T> (*this);
+  }
+
+  /// Dereference operator returns a reference to the item contained
+  /// at the current position
+  element_type operator* (void)
+    {
+      // Access the underlying element in the sequence.
+      return element_type ((*(this->sequence_))[this->pos_],
+                           this->sequence_->release ());
+    }
+
+  /// Returns a const reference to the item contained at the current position
+  const_element_type operator* (void) const
+    {
+      // Access the underlying element in the sequence.
+      return const_element_type ((*(this->sequence_))[this->pos_],
+                                 this->sequence_->release ());
+    }
+
+  /// Preincrement operator
+  BBS_Sequence_Iterator<SEQUENCE_T> &operator++ (void)
+    {
+      // Increment the position.
+      // We also need to check if we're now past the end.
+      ++this->pos_;
+      return *this;
+    }
+
+  /// Postincrement operator
+  BBS_Sequence_Iterator<SEQUENCE_T> operator++ (int)
+    {
+      // Create a temporary to return so that it's not modified.
+      BBS_Sequence_Iterator<SEQUENCE_T> temp_iter (this->sequence_, this->pos_);
+      // Increment the position.
+      // We also need to check if we're now past the end.
+      ++this->pos_;
+      return temp_iter;
+    }
+
+  /// Predecrement operator
+  BBS_Sequence_Iterator<SEQUENCE_T> &operator-- (void)
+    {
+      --this->pos_;
+      return *this;
+    }
+
+  /// Postdecrement operator
+  BBS_Sequence_Iterator<SEQUENCE_T> operator-- (int)
+    {
+      // Create a temporary to return so that it's not modified.
+      BBS_Sequence_Iterator<SEQUENCE_T> temp_iter (this->sequence_, this->pos_);
+      --this->pos_;
+      return temp_iter;
+    }
+
+  /// Iterator addition
+  BBS_Sequence_Iterator<SEQUENCE_T> &operator+= (difference_type n)
+    {
+      // Move ahead n elements.
+      this->pos_ += n;
+      return *this;
+    }
+
+  /// Iterator addition
+  BBS_Sequence_Iterator<SEQUENCE_T> operator+ (difference_type n)
+    {
+      // Create a temporary to return and move it ahead n elements.
+      return BBS_Sequence_Iterator<SEQUENCE_T> (this->sequence_, this->pos_ + n);
+    }
+
+  /// Iterator subtraction
+  BBS_Sequence_Iterator<SEQUENCE_T> &operator-= (difference_type n)
+    {
+      // Move back n elements.
+      this->pos_ -= n;
+      return *this;
+    }
+
+  /// Iterator subtraction
+  BBS_Sequence_Iterator<SEQUENCE_T> operator- (difference_type n)
+    {
+      // Create a temporary to return and move it back n elements.
+      return BBS_Sequence_Iterator<SEQUENCE_T> (this->sequence_, this->pos_ - n);
+    }
+
+  /// Difference
+  difference_type operator- (const BBS_Sequence_Iterator<SEQUENCE_T> & rhs)
+    {
+      // I think order is important here (i.e., this before rhs).
+      return this->pos_ - rhs.pos_;
+    }
+
+  /// Difference
+  difference_type operator- (const Const_BBS_Sequence_Iterator<SEQUENCE_T> & rhs)
+    {
+      // I think order is important here (i.e., this before rhs).
+      return this->pos_ - rhs.pos_;
+    }
+
+  /// Element operator/assignment
+  element_type operator[] (difference_type n)
+    {
+      // Return the element at position pos_ + n
+      return element_type ((*(this->sequence_))[this->pos_ + n],
+                           this->sequence_->release ());
+    }
+
+  /// Element operator/assignment
+  const_element_type operator[] (difference_type n) const
+    {
+      // Return the element at position pos_ + n
+      return const_element_type ((*(this->sequence_))[this->pos_ + n],
+                                 this->sequence_->release ());
+    }
+
+  /// Less than
+  bool operator< (const BBS_Sequence_Iterator<SEQUENCE_T> & rhs)
+    {
+      // Return if this iterator is less than the passed in iterator.
+      return this->pos_ < rhs.pos_;
+    }
+
+  /// Less than
+  bool operator< (const Const_BBS_Sequence_Iterator<SEQUENCE_T> & rhs)
+    {
+      // Return if this iterator is less than the passed in iterator.
+      return this->pos_ < rhs.pos_;
+    }
+
+
+  /// Equality operator
+  bool operator== (const BBS_Sequence_Iterator<SEQUENCE_T> &rhs) const
+  {
+    // Compare all the data members for equality.
+    return this->sequence_ == rhs.sequence_
+        && this->pos_ == rhs.pos_;
+  }
+
+  /// Nonequality operator
+  bool operator!= (const BBS_Sequence_Iterator<SEQUENCE_T> &rhs) const
+  {
+    return !(*this == rhs);
+  }
+
+private:
+  /// the sequence with which we are dealing
+  implementation_type *sequence_;
+
+  /// Our current position in the sequence.
+  mutable difference_type pos_;
+};
+
+
+/// Iterator addition with the difference_type being the first argument.
+template<typename SEQUENCE_T>
+ BBS_Sequence_Iterator<SEQUENCE_T>
+  operator+ (typename BBS_Sequence_Iterator<SEQUENCE_T>::difference_type n,
+             const BBS_Sequence_Iterator<SEQUENCE_T> & iter)
+   {
+     // Create an iter and move it ahead n elements.
+     return BBS_Sequence_Iterator<SEQUENCE_T> (iter.sequence_, iter.pos_ + n);
+   }
+
+/// Iterator subtraction with the difference_type being the first argument.
+template<typename SEQUENCE_T>
+ BBS_Sequence_Iterator<SEQUENCE_T> operator-
+   (typename BBS_Sequence_Iterator<SEQUENCE_T>::difference_type n,
+    BBS_Sequence_Iterator<SEQUENCE_T> iter)
+   {
+     // Create an iter and move it back n elements.
+     return BBS_Sequence_Iterator<SEQUENCE_T> (iter.sequence_, iter.pos_ - n);
+   }
+
+
+/**
+ * @class Const_BBS_Sequence_Iterator
+ * @brief Implements a random access iterator for generic sequence type classes.
+ *
+ * Note:  Having a const Iterator does not guarantee that the current
+ * *position* that it points to will not change, it only guarantees that
+ * you cannot change the underlying array!
+ */
+template <typename SEQUENCE_T>
+class Const_BBS_Sequence_Iterator 
+{
+  friend class BBS_Sequence_Iterator<SEQUENCE_T>;
+
+public:
+  // = Necessary traits
+  typedef std::random_access_iterator_tag iterator_category;
+  typedef typename SEQUENCE_T::value_type value_type;
+  typedef typename SEQUENCE_T::value_type *pointer;
+  typedef typename SEQUENCE_T::value_type &reference;
+  typedef typename SEQUENCE_T::const_element_type const_element_type;
+  typedef typename SEQUENCE_T::allocation_traits allocation_traits;
+  typedef typename SEQUENCE_T::element_traits element_traits;
+  typedef typename SEQUENCE_T::implementation_type implementation_type;
+  typedef int difference_type;
+
+  /// Construct a Const_BBS_Sequence_Iterator at position pos from
+  /// a const sequence.
+  Const_BBS_Sequence_Iterator (const implementation_type *sequence,
+                               size_t pos = 0)
+    : sequence_ (sequence),
+    pos_ (pos)
+      {
+      }
+
+  virtual ~Const_BBS_Sequence_Iterator ()
+    {
+    }
+
+  /// Copy constructor
+  Const_BBS_Sequence_Iterator (
+		Const_BBS_Sequence_Iterator<SEQUENCE_T> const & rhs)
+    : sequence_ (rhs.sequence_),
+    pos_ (rhs.pos_)
+      {
+      }
+
+  /// Copy constructor initializing by a BBS_Sequence_Iterator
+  Const_BBS_Sequence_Iterator (
+		BBS_Sequence_Iterator<SEQUENCE_T> const & rhs)
+    : sequence_ (rhs.sequence_),
+    pos_ (rhs.pos_)
+      {
+      }
+  
+  /// Assignment operator
+  Const_BBS_Sequence_Iterator & operator= (
+                Const_BBS_Sequence_Iterator<SEQUENCE_T> const & rhs)
+    {
+      Const_BBS_Sequence_Iterator tmp(rhs);
+      swap (tmp);
+      return * this;
+    }
+
+  /// swaps all members  
+  void swap(Const_BBS_Sequence_Iterator<SEQUENCE_T> & rhs) 
+    throw()
+    {
+      std::swap (sequence_, rhs.sequence_);
+      std::swap (this->pos_, rhs.pos_);
+    }
+
+  /// Dereference operator returns a reference to the item contained
+  /// at the current position
+  const_element_type operator* (void) const
+    {
+      // Access the underlying element in the sequence.
+      return const_element_type ((*(this->sequence_))[this->pos_],
+                                 this->sequence_->release ());
+    }
+
+  /// Preincrement operator
+  const Const_BBS_Sequence_Iterator<SEQUENCE_T> &operator++ (void) const
+    {
+      // Increment the position.
+      ++this->pos_;
+      return * this;
+    }
+
+  /// Postincrement operator
+  Const_BBS_Sequence_Iterator<SEQUENCE_T> operator++ (int) const
+    {
+      // Create a temporary to return so that it's not modified.
+      Const_BBS_Sequence_Iterator<SEQUENCE_T> temp_iter (this->sequence_, this->pos_);
+      // Increment the position.
+      // We also need to check if we're now past the end.
+      ++this->pos_;
+      return temp_iter;
+    }
+
+  /// Predecrement operator
+  const Const_BBS_Sequence_Iterator<SEQUENCE_T> &operator-- (void) const
+    {
+      --this->pos_;
+      return * this;
+    }
+
+  /// Postdecrement operator
+  Const_BBS_Sequence_Iterator<SEQUENCE_T> operator-- (int) const
+    {
+      // Create a temporary to return so that it's not modified.
+      Const_BBS_Sequence_Iterator<SEQUENCE_T> temp_iter (this->sequence_, this->pos_);
+      --this->pos_;
+      return temp_iter;
+    }
+
+  /// Iterator addition
+  const Const_BBS_Sequence_Iterator<SEQUENCE_T> &operator+= (difference_type n) const
+    {
+      // Move ahead n elements.
+      this->pos_ += n;
+      return * this;
+    }
+
+  /// Iterator addition
+  Const_BBS_Sequence_Iterator<SEQUENCE_T> operator+ (difference_type n) const
+    {
+      // Create a temporary to return and move it ahead n elements.
+      return Const_BBS_Sequence_Iterator<SEQUENCE_T> (this->sequence_, this->pos_ + n);
+    }
+
+  /// Iterator subtraction
+  const Const_BBS_Sequence_Iterator<SEQUENCE_T> &operator-= (difference_type n) const
+    {
+      // Move back n elements.
+      this->pos_ -= n;
+      return * this;
+    }
+
+  /// Iterator subtraction
+  Const_BBS_Sequence_Iterator<SEQUENCE_T> operator- (difference_type n) const
+    {
+      // Create a temporary to return and move it back n elements.
+      return Const_BBS_Sequence_Iterator<SEQUENCE_T> (this->sequence_, this->pos_ - n);
+    }
+
+  /// Difference
+  difference_type operator- (const Const_BBS_Sequence_Iterator<SEQUENCE_T> & rhs) const
+    {
+      // I think the order is important here (i.e., this before rhs).
+      return this->pos_ - rhs.pos_;
+    }
+
+  /// Element operator
+  const_element_type operator[] (difference_type n) const
+    {
+      // Return the element at position pos_ + n
+      return const_element_type ((*(this->sequence_))[this->pos_ + n],
+                                 this->sequence_->release ());
+    }
+
+  /// Less than
+  virtual bool operator< (const Const_BBS_Sequence_Iterator<SEQUENCE_T> & rhs) const
+    {
+      // Return if this iterator is less than the passed in iterator.
+      return this->pos_ < rhs.pos_;
+    }
+
+  /// Equality operator
+  bool operator== (const Const_BBS_Sequence_Iterator<SEQUENCE_T> &rhs) const
+  {
+    // Compare all the data members for equality.
+    return this->sequence_ == rhs.sequence_
+        && this->pos_ == rhs.pos_;
+  }
+
+  /// Nonequality operator
+  bool operator!= (const Const_BBS_Sequence_Iterator<SEQUENCE_T> &rhs) const
+  {
+    return !(*this == rhs);
+  }
+
+private:
+  /// the sequence with which we are dealing
+  const implementation_type *sequence_;
+
+  /// Our current position in the sequence.
+  mutable difference_type pos_;
+};
+
+/// Iterator addition with the difference_type being the first argument.
+template<typename SEQUENCE_T>
+ Const_BBS_Sequence_Iterator<SEQUENCE_T> operator+
+   (typename BBS_Sequence_Iterator<SEQUENCE_T>::difference_type n,
+    Const_BBS_Sequence_Iterator<SEQUENCE_T> iter)
+   {
+     // Create an iter and move it ahead n elements.
+     return Const_BBS_Sequence_Iterator<SEQUENCE_T> (iter.sequence_, iter.pos_ + n);
+   }
+
+/// Iterator subtraction with the difference_type being the first argument.
+template<typename SEQUENCE_T>
+ Const_BBS_Sequence_Iterator<SEQUENCE_T> operator-
+   (typename BBS_Sequence_Iterator<SEQUENCE_T>::difference_type n,
+    Const_BBS_Sequence_Iterator<SEQUENCE_T> iter)
+   {
+     // Create an iter and move it back n elements.
+     return Const_BBS_Sequence_Iterator<SEQUENCE_T> (iter.sequence_, iter.pos_ - n);
+   }
+
+
+/**
+ * @class BBS_Sequence_Reverse_Iterator
+ * @brief Implements a random access iterator for generic sequence type classes.
+ */
+template <typename SEQUENCE_T>
+class BBS_Sequence_Reverse_Iterator 
+{
+  friend class Const_BBS_Sequence_Reverse_Iterator<SEQUENCE_T>;
+
+public:
+  // = Necessary traits
+  typedef std::random_access_iterator_tag iterator_category;
+  typedef typename SEQUENCE_T::value_type value_type;
+  typedef typename SEQUENCE_T::value_type *pointer;
+  typedef typename SEQUENCE_T::value_type &reference;
+  typedef typename SEQUENCE_T::element_type element_type;
+  typedef typename SEQUENCE_T::const_element_type const_element_type;
+  typedef typename SEQUENCE_T::allocation_traits allocation_traits;
+  typedef typename SEQUENCE_T::element_traits element_traits;
+  typedef typename SEQUENCE_T::implementation_type implementation_type;
+  typedef int difference_type;
+
+  /// Construct a BBS_Sequence_Reverse_Iterator at position pos
+  BBS_Sequence_Reverse_Iterator (implementation_type *sequence, 
+                                 size_t pos)
+    : sequence_ (sequence),
+    pos_ (pos)
+      {
+      }
+
+  /// Copy constructor
+  BBS_Sequence_Reverse_Iterator (
+	BBS_Sequence_Reverse_Iterator<SEQUENCE_T> const & rhs)
+    : sequence_ (rhs.sequence_),
+    pos_ (rhs.pos_)
+      {
+      }
+  
+  /// Assignment operator
+  BBS_Sequence_Reverse_Iterator & operator= (
+	BBS_Sequence_Reverse_Iterator<SEQUENCE_T> const & rhs)
+    {
+      BBS_Sequence_Reverse_Iterator tmp(rhs);
+      swap (tmp);
+      return * this;
+    }
+
+  /// swaps all members
+  void swap(BBS_Sequence_Reverse_Iterator<SEQUENCE_T> & rhs) 
+    throw()
+    {
+      std::swap (sequence_, rhs.sequence_);
+      std::swap (this->pos_, rhs.pos_);
+    }
+
+  /// Dereference operator returns a reference to the item contained
+  /// at the current position
+  element_type operator* (void)
+    {
+      // Access the underlying element in the sequence.
+      return element_type ((*(this->sequence_))[this->pos_],
+                           this->sequence_->release ());
+    }
+
+  /// Returns a const reference to the item contained at the current position
+  const_element_type operator* (void) const
+    {
+      // Access the underlying element in the sequence.
+      return const_element_type ((*(this->sequence_))[this->pos_],
+                                 this->sequence_->release ());
+    }
+
+  /// Preincrement operator
+  BBS_Sequence_Reverse_Iterator<SEQUENCE_T> &operator++ (void)
+    {
+      // Decrement the position for reverse iterators.
+      // We also need to check if we're now before the start.
+      --this->pos_;
+      return *this;
+    }
+
+  /// Postincrement operator
+  BBS_Sequence_Reverse_Iterator<SEQUENCE_T> operator++ (int)
+    {
+      // Create a temporary to return so that it's not modified.
+      BBS_Sequence_Reverse_Iterator<SEQUENCE_T> temp_iter (this->sequence_, this->pos_);
+      // Decrement the position for reverse iterators.
+      // We also need to check if we're now past the end.
+      --this->pos_;
+      return temp_iter;
+    }
+
+  /// Predecrement operator
+  BBS_Sequence_Reverse_Iterator<SEQUENCE_T> &operator-- (void)
+    {
+      // Increment the position for reverse iterators.
+      ++this->pos_;
+      return *this;
+    }
+
+  /// Postdecrement operator
+  BBS_Sequence_Reverse_Iterator<SEQUENCE_T> operator-- (int)
+    {
+      // Create a temporary to return so that it's not modified.
+      BBS_Sequence_Reverse_Iterator<SEQUENCE_T> temp_iter (this->sequence_, this->pos_);
+      // Increment the position for reverse iterators.
+      ++this->pos_;
+      return temp_iter;
+    }
+
+  /// Iterator addition
+  BBS_Sequence_Reverse_Iterator<SEQUENCE_T> &operator+= (difference_type n)
+    {
+      // Move back n elements for reverse iterators.
+      this->pos_ -= n;
+      return *this;
+    }
+
+  /// Iterator addition
+  BBS_Sequence_Reverse_Iterator<SEQUENCE_T> operator+ (difference_type n)
+    {
+      // Create a temporary to return and move it back n elements for
+      // reverse iterators.
+      return BBS_Sequence_Reverse_Iterator<SEQUENCE_T> (this->sequence_, this->pos_ - n);
+    }
+
+  /// Iterator subtraction
+  BBS_Sequence_Reverse_Iterator<SEQUENCE_T> &operator-= (difference_type n)
+    {
+      // Move ahead n elements for reverse iterators.
+      this->pos_ += n;
+      return *this;
+    }
+
+  /// Iterator subtraction
+  BBS_Sequence_Reverse_Iterator<SEQUENCE_T> operator- (difference_type n)
+    {
+      // Create a temporary to return and move it ahead n elements for
+      // reverse iterators.
+      return BBS_Sequence_Reverse_Iterator<SEQUENCE_T> (this->sequence_, this->pos_ + n);
+    }
+
+  /// Difference
+  difference_type operator- (const BBS_Sequence_Reverse_Iterator<SEQUENCE_T> & rhs)
+    {
+      // I think order is important here (i.e., rhs before this).
+      return rhs.pos_ - this->pos_;
+    }
+
+  /// Difference
+  difference_type operator- (const Const_BBS_Sequence_Reverse_Iterator<SEQUENCE_T> & rhs)
+    {
+      // I think order is important here (i.e., rhs before this).
+      return rhs.pos_ - this->pos_;
+    }
+
+  /// Element operator/assignment
+  element_type operator[] (difference_type n)
+    {
+      // Return the element at position pos_ + n
+      return element_type ((*(this->sequence_))[this->pos_ + n],
+                           this->sequence_->release ());
+    }
+
+  /// Element operator/assignment
+  const_element_type operator[] (difference_type n) const
+    {
+      // Return the element at position pos_ + n
+      return const_element_type ((*(this->sequence_))[this->pos_ + n],
+                                 this->sequence_->release ());
+    }
+
+  /// Less than
+  bool operator< (const BBS_Sequence_Reverse_Iterator<SEQUENCE_T> & rhs)
+    {
+      // Return if this iterator is less than the passed in iterator.
+      // For reverse iterators reverse the logic.
+      return this->pos_ > rhs.pos_;
+    }
+
+  /// Less than
+  bool operator< (const Const_BBS_Sequence_Reverse_Iterator<SEQUENCE_T> & rhs)
+    {
+      // Return if this iterator is less than the passed in iterator.
+      // For reverse iterators reverse the logic.
+      return this->pos_ > rhs.pos_;
+    }
+
+
+  /// Equality operator
+  bool operator== (const BBS_Sequence_Reverse_Iterator<SEQUENCE_T> &rhs) const
+  {
+    // Compare all the data members for equality.
+    return this->sequence_ == rhs.sequence_
+           && this->pos_ == rhs.pos_;
+  }
+
+  /// Equality operator
+  bool operator== (const Const_BBS_Sequence_Reverse_Iterator<SEQUENCE_T> &rhs) const
+  {
+    // Compare all the data members for equality.
+    return this->sequence_ == rhs.sequence_
+           && this->pos_ == rhs.pos_;
+  }
+
+  /// Nonequality operator
+  bool operator!= (const BBS_Sequence_Reverse_Iterator<SEQUENCE_T> &rhs) const
+  {
+    return !(*this == rhs);
+  }
+
+  /// Nonequality operator
+  bool operator!= (const Const_BBS_Sequence_Reverse_Iterator<SEQUENCE_T> &rhs) const
+  {
+    return !(*this == rhs);
+  }
+
+private:
+  /// The sequence with which we are dealing
+  implementation_type *sequence_;
+
+  /// Our current position in the sequence.
+  mutable difference_type pos_;
+};
+
+/// Iterator addition with the difference_type being the first argument.
+template<typename SEQUENCE_T>
+ BBS_Sequence_Reverse_Iterator<SEQUENCE_T> operator+
+   (typename BBS_Sequence_Reverse_Iterator<SEQUENCE_T>::difference_type n,
+    BBS_Sequence_Reverse_Iterator<SEQUENCE_T> iter)
+   {
+     // Create an iter and move it back n elements for reverse iterators.
+     return BBS_Sequence_Reverse_Iterator<SEQUENCE_T> (iter.sequence_, iter.pos_ - n);
+   }
+
+/// Iterator subtraction with the difference_type being the first argument.
+template<typename SEQUENCE_T>
+ BBS_Sequence_Reverse_Iterator<SEQUENCE_T> operator-
+   (typename BBS_Sequence_Reverse_Iterator<SEQUENCE_T>::difference_type n,
+    BBS_Sequence_Reverse_Iterator<SEQUENCE_T> iter)
+   {
+     // Create an iter and move it ahead n elements for reverse iterators.
+     return BBS_Sequence_Reverse_Iterator<SEQUENCE_T> (iter.sequence_, iter.pos_ + n);
+   }
+
+
+/**
+ * @class Const_BBS_Sequence_Reverse_Iterator
+ * @brief Implements a random access iterator for generic sequence type classes.
+ *
+ * Note:  Having a const Iterator does not guarantee that the current
+ * *position* that it points to will not change, it only guarantees that
+ * you cannot change the underlying array!
+ */
+template <typename SEQUENCE_T>
+class Const_BBS_Sequence_Reverse_Iterator 
+{
+  friend class BBS_Sequence_Reverse_Iterator<SEQUENCE_T>;
+
+public:
+  // = Necessary traits
+  typedef std::random_access_iterator_tag iterator_category;
+  typedef typename SEQUENCE_T::value_type value_type;
+  typedef typename SEQUENCE_T::value_type *pointer;
+  typedef typename SEQUENCE_T::value_type &reference;
+  typedef typename SEQUENCE_T::const_element_type const_element_type;
+  typedef typename SEQUENCE_T::allocation_traits allocation_traits;
+  typedef typename SEQUENCE_T::element_traits element_traits;
+  typedef typename SEQUENCE_T::implementation_type implementation_type;
+  typedef int difference_type;
+
+  /// Construct a Const_BBS_Sequence_Reverse_Iterator at position pos
+  /// using a const sequence.
+  Const_BBS_Sequence_Reverse_Iterator (const implementation_type *sequence, 
+                                       size_t pos)
+    : sequence_ (sequence),
+    pos_ (pos)
+      {
+      }
+
+  /// Copy constructor
+  Const_BBS_Sequence_Reverse_Iterator (
+	Const_BBS_Sequence_Reverse_Iterator<SEQUENCE_T> const & rhs)
+    : sequence_ (rhs.sequence_),
+    pos_ (rhs.pos_)
+      {
+      }
+
+  /// Copy constructor
+  Const_BBS_Sequence_Reverse_Iterator (
+	BBS_Sequence_Reverse_Iterator<SEQUENCE_T> const & rhs)
+    : sequence_ (rhs.sequence_),
+    pos_ (rhs.pos_)
+      {
+      }
+  
+  /// Assignment operator
+  Const_BBS_Sequence_Reverse_Iterator & operator= (
+	Const_BBS_Sequence_Reverse_Iterator<SEQUENCE_T> const & rhs)
+    {
+      Const_BBS_Sequence_Reverse_Iterator tmp(rhs);
+      swap (tmp);
+      return * this;
+    }
+
+  /// swaps all members
+  void swap(Const_BBS_Sequence_Reverse_Iterator<SEQUENCE_T> & rhs) 
+    throw()
+    {
+      std::swap (sequence_, rhs.sequence_);
+      std::swap (this->pos_, rhs.pos_);
+    }
+
+  /// typecast operator to BBS_Sequence_Reverse_Iterator
+
+  /// Dereference operator returns a reference to the item contained
+  /// at the current position
+  const_element_type operator* (void) const
+    {
+      // Access the underlying element in the sequence.
+      return const_element_type ((*(this->sequence_))[this->pos_],
+                                 this->sequence_->release ());
+    }
+
+  /// Preincrement operator
+  const Const_BBS_Sequence_Reverse_Iterator<SEQUENCE_T> &operator++ (void) const
+    {
+      // Decrement the position for reveres iterators.
+      // We also need to check if we're now before the start.
+      --this->pos_;
+      return *this;
+    }
+
+  /// Postincrement operator
+  Const_BBS_Sequence_Reverse_Iterator<SEQUENCE_T> operator++ (int) const
+    {
+      // Create a temporary to return so that it's not modified.
+      Const_BBS_Sequence_Reverse_Iterator<SEQUENCE_T> temp_iter (this->sequence_, this->pos_);
+      // Decrement the position for reverse iterators.
+      // We also need to check if we're now before the start.
+      --this->pos_;
+      return temp_iter;
+    }
+
+  /// Predecrement operator
+  const Const_BBS_Sequence_Reverse_Iterator<SEQUENCE_T> &operator-- (void) const
+    {
+      // Increment the position for reverse iterators.
+      ++this->pos_;
+      return *this;
+    }
+
+  /// Postdecrement operator
+  Const_BBS_Sequence_Reverse_Iterator<SEQUENCE_T> operator-- (int) const
+    {
+      // Create a temporary to return so that it's not modified.
+      Const_BBS_Sequence_Reverse_Iterator<SEQUENCE_T> temp_iter (this->sequence_, this->pos_);
+      // Increment the position for reverse iterators.
+      ++this->pos_;
+      return temp_iter;
+    }
+
+  /// Iterator addition
+  const Const_BBS_Sequence_Reverse_Iterator<SEQUENCE_T> &operator+= (difference_type n) const
+    {
+      // Move back n elements for reverse iterators.
+      this->pos_ -= n;
+      return *this;
+    }
+
+  /// Iterator addition
+  Const_BBS_Sequence_Reverse_Iterator<SEQUENCE_T> operator+ (difference_type n) const
+    {
+      // Create a temporary to return and move it back n elements for
+      // reverse iterators.
+      return Const_BBS_Sequence_Reverse_Iterator<SEQUENCE_T> (this->sequence_, this->pos_ - n);
+    }
+
+  /// Iterator subtraction
+  const Const_BBS_Sequence_Reverse_Iterator<SEQUENCE_T> &operator-= (difference_type n) const
+    {
+      // Move ahead n elements for reverse iterators.
+      this->pos_ += n;
+      return *this;
+    }
+
+  /// Iterator subtraction
+  Const_BBS_Sequence_Reverse_Iterator<SEQUENCE_T> operator- (difference_type n) const
+    {
+      // Create a temporary to return and move it ahead n elements for
+      // reverse iterators.
+      return Const_BBS_Sequence_Reverse_Iterator<SEQUENCE_T> (this->sequence_, this->pos_ + n);
+    }
+
+  /// Difference
+  difference_type operator- (const Const_BBS_Sequence_Reverse_Iterator<SEQUENCE_T> & rhs) const
+    {
+      // I think order is important here (i.e., rhs before this).
+      return rhs.pos_ - this->pos_;
+    }
+
+  /// Element operator/assignment
+  const_element_type operator[] (difference_type n) const
+    {
+      // Return the element at position pos_ + n
+      return const_element_type ((*(this->sequence_))[this->pos_ + n],
+                                 this->sequence_->release ());
+    }
+
+  /// Less than
+  bool operator< (const Const_BBS_Sequence_Reverse_Iterator<SEQUENCE_T> & rhs) const
+    {
+      // Return if this iterator is less than the passed in iterator.
+      // For reverse iterators reverse the logic.
+      return this->pos_ > rhs.pos_;
+    }
+
+  /// Equality operator
+  bool operator== (const Const_BBS_Sequence_Reverse_Iterator<SEQUENCE_T> &rhs) const
+  {
+    // Compare all the data members for equality.
+    return this->sequence_ == rhs.sequence_
+        && this->pos_ == rhs.pos_;
+  }
+
+  /// Nonequality operator
+  bool operator!= (const Const_BBS_Sequence_Reverse_Iterator<SEQUENCE_T> &rhs) const
+  {
+    return !(*this == rhs);
+  }
+
+private:
+  /// the sequence with which we are dealing
+  const implementation_type *sequence_;
+
+  /// Our current position in the sequence.
+  mutable difference_type pos_;
+};
+
+/// Iterator addition with the difference_type being the first argument.
+template<typename SEQUENCE_T>
+ Const_BBS_Sequence_Reverse_Iterator<SEQUENCE_T> operator+
+   (typename Const_BBS_Sequence_Reverse_Iterator<SEQUENCE_T>::difference_type n,
+    Const_BBS_Sequence_Reverse_Iterator<SEQUENCE_T> iter)
+   {
+     // Create an iter and move it back n elements for reverse iterators.
+     return Const_BBS_Sequence_Reverse_Iterator<SEQUENCE_T> (iter.sequence_, iter.pos_ - n);
+   }
+
+/// Iterator subtraction with the difference_type being the first argument.
+template<typename SEQUENCE_T>
+ Const_BBS_Sequence_Reverse_Iterator<SEQUENCE_T> operator-
+   (typename Const_BBS_Sequence_Reverse_Iterator<SEQUENCE_T>::difference_type n,
+    Const_BBS_Sequence_Reverse_Iterator<SEQUENCE_T> iter)
+   {
+     // Create an iter and move it ahead n elements for reverse iterators.
+     return Const_BBS_Sequence_Reverse_Iterator<SEQUENCE_T> (iter.sequence_, iter.pos_ + n);
+   }
+
 } // namespace TAO
 
 TAO_END_VERSIONED_NAMESPACE_DECL