IndexVector.hpp

Go to the documentation of this file.

#ifndef IndexVector_HPP
#define IndexVector_HPP

#include "common.hpp"
#include "common/Edge.hpp"
#include <vector>
#include <iterator>     //for test


namespace Bodon
{
   class IndexVector : private std::vector<void*>
   {
      public:

         class iterator
         {
               friend class IndexVector;
            private:
               IndexVector* oiv;
               std::vector<void*>::iterator it;
            public:            
               iterator(){}

               iterator( IndexVector* oiv, 
                         const std::vector<void*>::iterator& it) : 
                  oiv(oiv), it(it){}

               Edge operator*() const
               {
                  return Edge( it - static_cast< std::vector<void*>* >(oiv)->begin(),
                               *it );
               }
               iterator& operator++()
               {
                  do ++it;
                  while( it != static_cast< std::vector<void*>* >(oiv)->end() && 
                         *it == NULL );
                  return *this;
               }
               
               iterator& operator=(const iterator& an_it)
               {
                  if( this != &an_it )
                  {
                     oiv = an_it.oiv;
                     it = an_it.it;
                  }
                  return *this;
               }
               bool operator==(const iterator& an_it) const
               {
                  return it == an_it.it;
               }

               bool operator!=(const iterator& an_it) const
               {
                  return it != an_it.it;
               }
         };

      public:
         IndexVector() : std::vector<void*>(){}
         iterator begin()
         {
            std::vector<void*>::iterator it(std::vector<void*>::begin());
            while(it != std::vector<void*>::end() && *it == NULL)
               ++it;
            return iterator(this, it);
         }

         iterator end()
         {
            return iterator(this, std::vector<void*>::end());
         }
         void clear()
         {
            std::vector<void*>::erase( std::vector<void*>::begin(), 
                                       std::vector<void*>::end() );
         }
         bool empty() const
         {
            return std::vector<void*>::begin() == std::vector<void*>::end();
         }
         void*& getSubtrie(item_t label)
         {
            return operator[](label);
         }
         void quickErase(item_t pos);
         iterator erase(iterator pos);
        
         void* find(item_t label) const
         {
            if( label >= size() )
               return NULL;
            else 
               return operator[](label);
         }

         void*& findOrCreate(item_t label)
         {
            if( label >= size() )
               resize(label+1, NULL);
            return operator[](label);
         }
         bool lookup(item_t label, void*& subtrie) const
         {
            if( label >= size() )
               return false;
            else
            {
               subtrie = operator[](label);
               return true;
            }
         }
         void insert(const std::vector<Edge>& new_edges);

         static bool isLookupPreferred()
         {
            return true;
         }
   };
   inline void IndexVector::insert(const std::vector<Edge>& new_edges)
   {
      if(!new_edges.empty())
      {
         reserve(new_edges.back().first + 1 );
         resize(new_edges.back().first + 1, NULL);
         for( std::vector<Edge>::const_iterator it = new_edges.begin();
              it != new_edges.end(); ++it)
            operator[]((*it).first) = (*it).second;
      }
   }

   inline void IndexVector::quickErase(item_t pos)
   {
      if( pos == size() - 1 )
      {
         do
         {
            pop_back();
         }
         while( !empty() && back() == NULL );
      }
      else
         operator[](pos) = NULL;
   }

   inline IndexVector::iterator IndexVector::
   erase(IndexVector::iterator pos)
   {
      if(pos.it == --std::vector<void*>::end())
      {
         do
         {
            pop_back();
         }
         while( !empty() && back() == NULL );
         return end();
      }
      else
      {
         *(pos.it) = NULL;
         return ++pos;
      }
   }
}

#endif

---