/home/mhx/git/github/libmoost/include/moost/kvds/kvds_key_iterator.hpp

Go to the documentation of this file.

/* vim:set ts=3 sw=3 sts=3 et: */

#include <cassert>
#include <stdexcept>
#include <vector>

#include <boost/shared_ptr.hpp>
#include <boost/type_traits.hpp>
#include <boost/static_assert.hpp>

#ifndef MOOST_KVDS_KVDS_ITERATOR_HPP__
#define MOOST_KVDS_KVDS_ITERATOR_HPP__

namespace moost { namespace kvds {




   template <typename kvdsT>
   class KvdsKeyIterator
   {
   public:
      typedef typename kvdsT::key_type key_type;

   private:
      typedef typename kvdsT::kvds_key_t kvds_key_t;

      void get_next_key()
      {
         assert(ikvds_ptr_);

         if(ikvds_ptr_)
         {
            if(ikvds_ptr_->nxt(&key_, key_.size()))
            {
               *key_; 
               ++pos_;
            }
            else
            {
               if(key_.size() != 0)
               {
                  throw std::runtime_error("unexpected key size");
               }

               ikvds_ptr_.reset();
            }
         }
      }

      void init()
      {
         assert(ikvds_ptr_);

         if(!ikvds_ptr_ || !ikvds_ptr_->beg())
         {
            throw std::runtime_error("failed to initialise iterator");
         }

         get_next_key();
      }

   public:
      KvdsKeyIterator() : key__(0), key_(key__), pos_(0) {}

      KvdsKeyIterator(kvdsT const & kvds) :
         key__(0), key_(key__), ikvds_ptr_(kvds.get_ikvds_ptr())
      {
         init();
      }

      KvdsKeyIterator(ikvds_ptr_t ikvds_ptr) :
         key__(0), key_(key__), pos_(0), ikvds_ptr_(ikvds_ptr)
      {
         init();
      }

      KvdsKeyIterator(KvdsKeyIterator const & rhs) :
         key__(rhs.key__), key_(key__), pos_(rhs.pos_), ikvds_ptr_(rhs.ikvds_ptr_)
      {
      }

      KvdsKeyIterator & operator = (KvdsKeyIterator const & rhs)
      {
         if(this != &rhs)
         {
            ikvds_ptr_ = rhs.ikvds_ptr_;
            key__ = rhs.key__;
            pos_ = rhs.pos_;
         }

         return *this;
      }

      KvdsKeyIterator & operator ++ () // prefix
      {
         if(!ikvds_ptr_)
         {
            assert(false);
            throw std::runtime_error("invalid iterator");
         }

         get_next_key();

         return *this;
      }

      KvdsKeyIterator operator ++ (int) // postfix
      {
         KvdsKeyIterator tmp = *this;

         if(!ikvds_ptr_)
         {
            assert(false);
            throw std::runtime_error("invalid iterator");
         }

         get_next_key();

         return tmp;
      }

      bool operator == (KvdsKeyIterator const & rhs) const
      {
         if(!ikvds_ptr_ && !rhs.ikvds_ptr_) { return true; }
         if(ikvds_ptr_ && rhs.ikvds_ptr_) { return pos_ == rhs.pos_; }
         return false;
      }

      bool operator != (KvdsKeyIterator const & rhs) const
      {
         return !(*this == rhs);
      }

      key_type const & operator * () const
      {
         if(!ikvds_ptr_)
         {
            assert(false);
            throw std::runtime_error("invalid iterator");
         }

         return *key_;
      }

   private:
      key_type key__;
      kvds_key_t key_;
      size_t pos_;
      ikvds_ptr_t ikvds_ptr_;
   };


}}

#endif // MOOST_KVDS_KVDS_ITERATOR_HPP__