BankStream_AMOS.hh

Go to the documentation of this file.

#ifndef __BankStream_AMOS_HH
#define __BankStream_AMOS_HH 1

#include "Bank_AMOS.hh"
#include <vector>




namespace AMOS {

//================================================ BankStream_t ================
//==============================================================================
class BankStream_t : public Bank_t
{

protected:

  static const Size_t DEFAULT_BUFFER_SIZE;

  static const Size_t MAX_OPEN_PARTITIONS;


  //--------------------------------------------------- init -------------------
  void init()
  {
    oldPartition_m = NULL;
    fixed_store_only_m = false;
    eof_m = false;
    curr_bid_m = 1;
    ate_m = false;
    triples_m . resize (1);
  }


  //--------------------------------------------------- inrange ----------------
  bool inrange()
  {
    return ( curr_bid_m > 0  &&  curr_bid_m <= last_bid_m );
  }
  

  bool fixed_store_only_m;            
  bool eof_m;                         
  ID_t curr_bid_m;                    
  bool ate_m;                         
  std::vector<const IDMap_t::HashTriple_t *> triples_m;   

  BankPartition_t * oldPartition_m;

public:

  enum bankseekdir
    {
      BEGIN,
      CURR,
      END
    };


  //--------------------------------------------------- BankStream_t -----------
  BankStream_t (NCode_t type)
    : Bank_t (type)
  {
    init();
    triples_m [NULL_ID] = NULL;
    buffer_size_m = DEFAULT_BUFFER_SIZE;
    max_partitions_m = MAX_OPEN_PARTITIONS;
  }


  //--------------------------------------------------- BankStream_t -----------
  BankStream_t (const std::string & type)
    : Bank_t (type)
  {
    init();
    triples_m [NULL_ID] = NULL;
    buffer_size_m = DEFAULT_BUFFER_SIZE;
    max_partitions_m = MAX_OPEN_PARTITIONS;
  }


  //--------------------------------------------------- ~BankStream_t ----------
  ~BankStream_t()
  {
    if ( is_open_m )
      close();
  }


  //--------------------------------------------------- append -----------------
  void append (IBankable_t & obj)
  {
    operator<< (obj);
  }


  //--------------------------------------------------- assignEID --------------
  void assignEID (ID_t iid, const std::string & eid);


  //--------------------------------------------------- assignIID --------------
  void assignIID (const std::string & eid, ID_t iid);


  //--------------------------------------------------- clean ------------------
  void clean();


  //--------------------------------------------------- clear ------------------
  void clear()
  {
    init();
    Bank_t::clear();
  }


  //--------------------------------------------------- close ------------------
  void close()
  {
    init();
    Bank_t::close();
  }


  //--------------------------------------------------- concat -----------------
  void concat (BankStream_t & source);


  //--------------------------------------------------- create -----------------
  void create (const std::string & dir, BankMode_t mode = B_READ | B_WRITE)
  {
    init();
    Bank_t::create (dir, mode);
  }


  //--------------------------------------------------- destroy ----------------
  void destroy()
  {
    init();
    Bank_t::destroy();
  }


  //--------------------------------------------------- eof --------------------
  bool eof() const
  {
    return ( is_open_m ? eof_m : true );
  }


  //--------------------------------------------------- fetch ------------------
  void fetch (ID_t iid, IBankable_t & obj)
  {
    Bank_t::fetch (iid, obj);
    oldPartition_m = NULL;
  }

  //--------------------------------------------------- fetch ------------------
  void fetch (const std::string & eid, IBankable_t & obj)
  {
    Bank_t::fetch (eid, obj);
    oldPartition_m = NULL;
  }

  //--------------------------------------------------- fetchFix ---------------
  void fetchFix (ID_t iid, IBankable_t & obj)
  {
    Bank_t::fetchFix(iid, obj);
    oldPartition_m = NULL;
  }

  //--------------------------------------------------- fetchFix ---------------
  void fetchFix (const std::string & eid, IBankable_t & obj)
  {
    Bank_t::fetchFix(eid, obj);
    oldPartition_m = NULL;
  }



  //--------------------------------------------------- ignore -----------------
  BankStream_t & ignore (bankstreamoff n);


  //--------------------------------------------------- open -------------------
  void open (const std::string & dir, BankMode_t mode = B_READ | B_WRITE);


  //--------------------------------------------------- remove -----------------
  void remove (ID_t iid)
  {
    ate_m = false;

    ID_t bid = lookupBID (iid);
    removeBID (bid);
    triples_m [bid] = NULL;
    idmap_m . remove (iid);

    oldPartition_m = NULL;
  }


  //--------------------------------------------------- remove -----------------
  void remove (const std::string & eid)
  {
    ate_m = false;

    ID_t bid = lookupBID (eid);
    removeBID (bid);
    triples_m [bid] = NULL;
    idmap_m . remove (eid);

    oldPartition_m = NULL;
  }

  //--------------------------------------------------- remove -----------------
  void removeByBID(ID_t bid)
  {
    if (bid < 0 || bid > last_bid_m)
    {
      AMOS_THROW_IO ("Cannot replaceByBID: outside valid bid range");
    }

    ate_m = false;
    removeBID(bid);

    if (triples_m[bid])
    {
      if (triples_m[bid]->iid) 
      { 
        idmap_m.remove(triples_m[bid]->iid); 
      }
      else if (!triples_m[bid]->eid.empty()) 
      { 
        idmap_m.remove(triples_m[bid]->eid); 
      }

      triples_m[bid] = NULL;
    }

    oldPartition_m = NULL;
  }


  //--------------------------------------------------- replace ----------------
  void replace (ID_t iid, IBankable_t & obj);


  //--------------------------------------------------- replace ----------------
  void replace (const std::string & eid, IBankable_t & obj);


  //--------------------------------------------------- replaceByBID -----------
  void replaceByBID(ID_t bid, IBankable_t & obj);



  //--------------------------------------------------- setFixedStoreOnly ------
  void setFixedStoreOnly(bool onlyFixed)
  {
    fixed_store_only_m = onlyFixed;
  }


  //--------------------------------------------------- seekg ------------------
  BankStream_t & seekg (bankstreamoff off, bankseekdir dir)
  {
    if ( ! is_open_m  ||  ! (mode_m & B_READ) )
      AMOS_THROW_IO ("Cannot seekg: bank not open for reading");

    switch ( dir )
      {
      case BEGIN: curr_bid_m = 1; break;
      case END:   curr_bid_m = last_bid_m + 1; break;
      case CURR:  break;
      default:    AMOS_THROW ("Cannot seekg: bad bankseekdir value");
      }
    ignore (off);
    oldPartition_m = NULL;

    return *this;
  }


  //--------------------------------------------------- seekg ------------------
  BankStream_t & seekg (ID_t pos)
  {
    if ( ! is_open_m  ||  ! (mode_m & B_READ) )
      AMOS_THROW_IO ("Cannot seekg: bank not open for reading");

    if ( pos != curr_bid_m )
      {
        curr_bid_m = pos;
        eof_m = !inrange();
      }

    oldPartition_m = NULL;

    return *this;
  }


  //--------------------------------------------------- tellg ------------------
  ID_t tellg() const
  {
    return curr_bid_m;
  }


  //--------------------------------------------------- tellp ------------------
  ID_t tellp() const
  {
    return last_bid_m + 1;
  }


  //--------------------------------------------------- operator bool() --------
  operator bool() const
  {
    return !eof();
  }


  //--------------------------------------------------- operator! --------------
  bool operator!() const
  {
    return eof();
  }


  //--------------------------------------------------- operator>> -------------
  BankStream_t & operator>> (IBankable_t & obj);


  //--------------------------------------------------- operator<< -------------
  BankStream_t & operator<< (IBankable_t & obj);
};

} // namespace AMOS

#endif // #ifndef __BankStream_AMOS_HH

---