vecincaccess.h

Go to the documentation of this file.

#ifndef  _MY_FaceBC_
#define _MY_FaceBC_

#include <vector>
#include <ostream>


template<class _Data>
class VecIncAccess;

template<class _Data>
std::ostream& operator<< (std::ostream &out, const VecIncAccess<_Data> &v);



template <class  _Data>
class  VecIncAccess 
{
 protected:
  class Node {
  public:
    Node(Index index,_Data &data)
      :index(index),data(data){}
    Node(){}
    Index index;
    _Data data;
  };
  std::vector<Node> m_list;
 protected:

 public:

  typedef typename std::vector<Node>::const_iterator data_iterator;


  
  class iterator
  {
    friend class VecIncAccess<_Data>;
  private:

  protected:
    VecIncAccess<_Data> *p;
    typename std::vector<Node>::iterator it;


  iterator(VecIncAccess<_Data> *p,
           typename std::vector<Node>::iterator  it)
    :p(p),it(it){}


  bool checkIncSearch(const typename std::vector<Node>::const_iterator  &it,unsigned index) const
  {
    if (index == INDEX_MAX)
      return false;

    if (it == p->m_list.end())
      return false;

    if (it != p->m_list.begin())
    {
     typename std::vector<Node>::const_iterator itprev=it;
      itprev--;
      if (index < itprev->index)
        return false;
    }
    return true;
  }


  public:

    
  
    _Data* inc_search(Index index) 
    {
      assert(checkIncSearch(it,index));
      if (index < it->index)
        return  NULL;
      else if (index == it->index)
        return &(it->data);
      else
      {
        it++;
        if (index < it->index)
          return NULL;
        else
        {
          assert(index == it->index);
          return &(it->data);
        }
      }
               
    }
  };


  class cyclic_iterator 
  {
    friend class VecIncAccess<_Data>;

    VecIncAccess<_Data> *p;
    typename std::vector<Node>::const_iterator it;
    bool wentToFirst;
  protected:
  cyclic_iterator(VecIncAccess<_Data> *p,
           typename std::vector<Node>::const_iterator  it)
    :p(p),it(it),wentToFirst(false){}
    
  public:
  const _Data* search(Index index)
    {
      if (wentToFirst)
      {
        if (index > it->index)
          return NULL;
        else if (index < it->index)
        {
          wentToFirst=false;
          return NULL;
        }
        else
        {
          wentToFirst=false;
          return &(it->data);
        }
      }
      if (index < it->index)
        return  NULL;
      else if (index == it->index)
        return &(it->data);
      else
      {
        it++;
        if (it->index == INDEX_MAX)
        {
          it =p->begin();
          wentToFirst=1;
        }
        else
        {
          if (index < it->index)
            return NULL;
          else
          {
            assert(index == it->index);
            return &(it->data);
          }
        }
      }


    }



    

    
  };//end iterator definitio 


  friend std::ostream& operator<< <>(std::ostream &out, const VecIncAccess<_Data> &v); 

  VecIncAccess(){
    Node node;
    node.index=INDEX_MAX;
    m_list.push_back(node);
  }

  void push_back(Index index,const _Data &data)
  {
    Node node;
    node.index=index;
    node.data = data;
    m_list.push_back(node);
    std::swap(m_list.back(),m_list[m_list.size()-2]);
  }
  iterator  begin(){return iterator(this,m_list.begin());}

  cyclic_iterator begin_cyclic(){return cyclic_iterator(this,m_list.begin());}

  data_iterator begin_data(){return m_list.begin();}
  data_iterator end_data(){assert(m_list.size() != 0);
                           return m_list.begin() + (m_list.size() -1);}
  
  void reserve(unsigned size)
  {
    m_list.reserve(size+2);
  }
  
  Index size(){return m_list.size()-1;}
  
};


template<class _Data>
std::ostream& operator<< (std::ostream &out, const VecIncAccess<_Data> &v)
{
  typename std::vector< typename VecIncAccess<_Data>::Node >::const_iterator it=v.m_list.begin();
  while(it!=v.m_list.end())
  {
    out << it->index << " " << it->data << "\n";
  }


  return out;
}


#endif

---