IDMap_AMOS.hh

Go to the documentation of this file.

#ifndef __IDMap_AMOS_HH
#define __IDMap_AMOS_HH 1

#include "Message_AMOS.hh"
#include <string>
#include <vector>




namespace AMOS {

//================================================ IDMap_t =====================
//==============================================================================
class IDMap_t : public IMessagable_t
{

public:

  //============================================== HashTriple_t ================
  //============================================================================
  struct HashTriple_t
  {
    uint8_t  c;               
    ID_t   iid;               
    ID_t   bid;               
    std::string eid;          

    //------------------------------------------------- HashTriple_t -----------
    HashTriple_t (ID_t iid_p, const std::string & eid_p, ID_t bid_p)
      : c (0), iid (iid_p), eid (eid_p), bid (bid_p)
    { }

    //------------------------------------------------- ~HashTriple_t ----------
    ~HashTriple_t ( )
    { }

    //------------------------------------------------- operator= --------------
    HashTriple_t & operator= (const HashTriple_t & s);

  };


private:

  static const Size_t DEFAULT_NUM_BUCKETS;  

  //============================================== HashNode_t ==================
  //============================================================================
  struct HashNode_t
  {
    HashNode_t * next;        
    HashTriple_t * triple;    

    //------------------------------------------------- HashNode_t -------------
    HashNode_t ( )
      : next (NULL), triple (NULL)
    { }


    //------------------------------------------------- ~HashNode_t ------------
    ~HashNode_t ( )
    { }


    //------------------------------------------------- clear ------------------
    void clear ( );


    //------------------------------------------------- clearchain -------------
    void clearchain ( )
    {
      if ( next != NULL )
        next -> clearchain( );
      clear( );
    }
  };


  //============================================== iterator ====================
  //============================================================================
  class iterator
  {
  private:
    std::vector<HashNode_t> * iid_bucs;
    std::vector<HashNode_t> * eid_bucs;
    std::vector<HashNode_t>::iterator buc;
    HashNode_t * curr;
    bool iids;
    
  public:
    iterator ( )
    { curr = NULL; }
    iterator (std::vector<HashNode_t> * iid_bucs_p,
              std::vector<HashNode_t> * eid_bucs_p);
    HashTriple_t & operator*() const
    { return *(curr -> triple); }
    operator HashTriple_t * () const
    { return (curr == NULL ? NULL : curr -> triple); }
    HashTriple_t * operator->() const
    { return (curr == NULL ? NULL : curr -> triple); }
    iterator & operator++();
    iterator operator++(int)
    {
      iterator tmp = *this;
      this->operator++();
      return tmp;
    }
  };


  //--------------------------------------------------- begin ------------------
  iterator begin ( )
  {
    return iterator (&iid_bucs_m, &eid_bucs_m);
  }


  //--------------------------------------------------- end --------------------
  iterator end ( )
  {
    return iterator ( );
  }


  //--------------------------------------------------- minbuckets -------------
  Size_t minbuckets (Size_t min);


  //--------------------------------------------------- hashfunc ---------------
  HashNode_t * hashfunc (ID_t key) const
  {
    return &((HashNode_t &)(iid_bucs_m [key % getBuckets( )]));
  }


  //--------------------------------------------------- hashfunc ---------------
  HashNode_t * hashfunc (const std::string & key) const
  {
    int c;
    unsigned long h = 5381;
    std::string::const_iterator i;
    std::string::const_iterator end = key . end( );

    for ( i = key . begin( ); i != end; i ++ )
      h = ((h << 5) + h) ^ (*i);

    return &((HashNode_t &)(eid_bucs_m [h % getBuckets( )]));
  }


  //--------------------------------------------------- lookupnode -------------
  bool lookupnode (ID_t key, HashNode_t * & node) const;


  //--------------------------------------------------- lookupnode -------------
  bool lookupnode (const std::string & key, HashNode_t * & node) const;


  //--------------------------------------------------- removenode -------------
  void removenode (HashNode_t * curr, HashNode_t * prev);


  std::vector<HashNode_t> iid_bucs_m;   
  std::vector<HashNode_t> eid_bucs_m;   
  Size_t size_m;                        
  NCode_t type_m;                       


public:

  static const NCode_t NCODE;


  //============================================== const_iterator ==============
  //============================================================================
  class const_iterator
  {
  private:
    const std::vector<HashNode_t> * iid_bucs;
    const std::vector<HashNode_t> * eid_bucs;
    std::vector<HashNode_t>::const_iterator buc;
    const HashNode_t * curr;
    bool iids;
    
  public:
    const_iterator ( )
    { curr = NULL; }
    const_iterator (const std::vector<HashNode_t> * iid_bucs_p,
                    const std::vector<HashNode_t> * eid_bucs_p);
    const HashTriple_t & operator*() const
    { return *(curr -> triple); }
    operator const HashTriple_t * () const
    { return (curr == NULL ? NULL : curr -> triple); }
    const HashTriple_t * operator->() const
    { return (curr == NULL ? NULL : curr -> triple); }
    const_iterator & operator++();
    const_iterator operator++(int)
    {
      const_iterator tmp = *this;
      this->operator++();
      return tmp;
    }
  };


  //--------------------------------------------------- IDMap_t ----------------
  IDMap_t ( )
    : size_m (0), type_m (NULL_NCODE)
  {
    resize (DEFAULT_NUM_BUCKETS);
  }


  //--------------------------------------------------- IDMap_t ----------------
  IDMap_t (Size_t buckets)
    : size_m (0), type_m (NULL_NCODE)
  {
    resize (buckets);
  }


  //--------------------------------------------------- IDMap_t ----------------
  IDMap_t (const IDMap_t & source)
    : size_m (0), type_m (NULL_NCODE)
  {
    *this = source;
  }


  //--------------------------------------------------- ~IDMap_t ---------------
  ~IDMap_t ( )
  {
    clear( );
  }


  //--------------------------------------------------- begin ------------------
  const_iterator begin ( ) const
  {
    return const_iterator (&iid_bucs_m, &eid_bucs_m);
  }


  //--------------------------------------------------- end --------------------
  const_iterator end ( ) const
  {
    return const_iterator ( );
  }


  //--------------------------------------------------- clear ------------------
  void clear ( );


  //--------------------------------------------------- concat -----------------
  void concat (const IDMap_t & source);


  //--------------------------------------------------- empty ------------------
  bool empty ( ) const
  {
    return (size_m == 0);
  }


  //--------------------------------------------------- exists -----------------
  bool exists (const std::string & key) const
  {
    HashNode_t * curr;
    return lookupnode (key, curr);
  }


  //--------------------------------------------------- exists -----------------
  bool exists (ID_t key) const
  {
    HashNode_t * curr;
    return lookupnode (key, curr);
  }


  //--------------------------------------------------- getBuckets -------------
  Size_t getBuckets ( ) const
  {
    return iid_bucs_m . size( );
  }


  //--------------------------------------------------- getNCode ---------------
  virtual NCode_t getNCode ( ) const
  {
    return IDMap_t::NCODE;
  }


  //--------------------------------------------------- getSize ----------------
  Size_t getSize ( ) const
  {
    return size_m;
  }


  //--------------------------------------------------- getType ----------------
  NCode_t getType ( ) const
  {
    return type_m;
  }


  //--------------------------------------------------- insert -----------------
  const HashTriple_t * insert (ID_t iid,
                               const std::string & eid,
                               ID_t bid = NULL_ID);


  //--------------------------------------------------- insertEID --------------
  const HashTriple_t * insert (const std::string & eid, ID_t bid = NULL_ID)
  {
    return insert (NULL_ID, eid, bid);
  }


  //--------------------------------------------------- insertIID --------------
  const HashTriple_t * insert (ID_t iid, ID_t bid = NULL_ID)
  {
    return insert (iid, NULL_STRING, bid);
  }


  //--------------------------------------------------- lookupBID --------------
  ID_t lookupBID (const std::string & key) const
  {
    HashNode_t * curr;
    if ( !lookupnode (key, curr) )
      return NULL_ID;
    return curr -> triple -> bid;
  }


  //--------------------------------------------------- lookupBID --------------
  ID_t lookupBID (ID_t key) const
  {
    HashNode_t * curr;
    if ( !lookupnode (key, curr) )
      return NULL_ID;
    return curr -> triple -> bid;
  }


  //--------------------------------------------------- lookupEID --------------
  const std::string & lookupEID (ID_t key) const
  {
    HashNode_t * curr;
    if ( !lookupnode (key, curr) )
      return NULL_STRING;
    return curr -> triple -> eid;
  }


  //--------------------------------------------------- lookupIID --------------
  ID_t lookupIID (const std::string & key) const
  {
    HashNode_t * curr;
    if ( !lookupnode (key, curr) )
      return NULL_ID;
    return curr -> triple -> iid;
  }


  //--------------------------------------------------- operator= --------------
  IDMap_t & operator= (const IDMap_t & source);


  //--------------------------------------------------- readMessage ------------
  virtual void readMessage (const Message_t & msg);


  //--------------------------------------------------- remove -----------------
  void remove (ID_t key);


  //--------------------------------------------------- remove -----------------
  void remove (const std::string & key);


  //--------------------------------------------------- resize -----------------
  void resize (Size_t min);


  //--------------------------------------------------- writeMessage -----------
  virtual void writeMessage (Message_t & msg) const;


  //--------------------------------------------------- read -------------------
  void read(const std::string & path);


  //--------------------------------------------------- setType ----------------
  void setType (NCode_t type)
  {
    type_m = type;
  }


  //--------------------------------------------------- write ------------------
  void write (std::ostream & out) const;

};

} // namespace AMOS

#endif // #ifndef __IDMap_AMOS_HH

---