Bank_AMOS.hh

Go to the documentation of this file.

//-- IMPORTANT DEVELOPERS NOTE

#ifndef __Bank_AMOS_HH
#define __Bank_AMOS_HH 1

#include "utility_AMOS.hh"
#include "IDMap_AMOS.hh"
#include <cstdlib>
#include <string>
#include <fstream>
#include <vector>
#include <deque>



namespace AMOS {

typedef uint8_t BankMode_t;
const BankMode_t B_READ   = 0x1;  
const BankMode_t B_WRITE  = 0x2;  
const BankMode_t B_SPY    = 0x4;



//================================================ IBankable_t =================
//==============================================================================
class IBankable_t
{
  friend class Bank_t;       
  friend class BankStream_t; 


protected:

  ID_t iid_m;                

  std::string eid_m;         

  BankFlags_t flags_m;       


  //--------------------------------------------------- readRecord -------------
  virtual void readRecord (std::istream & fix, std::istream & var) = 0;


  //--------------------------------------------------- writeRecord ------------
  virtual void writeRecord (std::ostream & fix, std::ostream & var) const = 0;


public:

  //--------------------------------------------------- IBankable_t ------------
  IBankable_t ( )
  {
    iid_m = NULL_ID;
  }


  //--------------------------------------------------- IBankable_t ------------
  IBankable_t (const IBankable_t & source)
  {
    *this = source;
  }


  //--------------------------------------------------- ~IBankable_t -----------
  virtual ~IBankable_t ( )
  {

  }


  //--------------------------------------------------- clear ------------------
  virtual void clear ( )
  {
    iid_m = NULL_ID;
    eid_m . erase( );
    flags_m . clear( );
  }


  //--------------------------------------------------- getEID -----------------
  const std::string & getEID ( ) const
  {
    return eid_m;
  }


  //--------------------------------------------------- getIID -----------------
  ID_t getIID ( ) const
  {
    return iid_m;
  }


  //--------------------------------------------------- getNCode ---------------
  virtual NCode_t getNCode ( ) const = 0;


  //--------------------------------------------------- isRemoved --------------
  bool isRemoved ( ) const
  {
    return flags_m . is_removed;
  }


  //--------------------------------------------------- isModified -------------
  bool isModified ( ) const
  {
    return flags_m . is_modified;
  }


  //--------------------------------------------------- isFlagA ----------------
  bool isFlagA ( ) const
  {
    return flags_m . is_flagA;
  }


  //--------------------------------------------------- isFlagB ----------------
  bool isFlagB ( ) const
  {
    return flags_m . is_flagB;
  }


  //--------------------------------------------------- setEID -----------------
  void setEID (const std::string & eid)
  {
    std::string::size_type s = eid . find (NL_CHAR);
    if (s == std::string::npos )
      eid_m = eid;
    else
      eid_m . assign (eid, 0, s);
  }


  //--------------------------------------------------- setFlagA ---------------
  void setFlagA (bool flag)
  {
    flags_m . is_flagA = flag;
  }


  //--------------------------------------------------- setFlagB ---------------
  void setFlagB (bool flag)
  {
    flags_m . is_flagB = flag;
  }


  //--------------------------------------------------- setIID -----------------
  void setIID (ID_t iid)
  {
    iid_m = iid;
  }

};




//================================================ Bank_t ======================
//==============================================================================
class Bank_t
{

protected:

  static const Size_t DEFAULT_BUFFER_SIZE;     
  static const Size_t DEFAULT_PARTITION_SIZE;  
  static const Size_t MAX_OPEN_PARTITIONS;     

  enum IFOMode_t
    {
      I_OPEN,
      I_CREATE,
      I_CLOSE,
    };


  //================================================ BankPartition_t ===========
  //============================================================================
  class BankPartition_t
  {

  private:

    char * fix_buff;     
    char * var_buff;     


  public:

    std::string fix_name;    
    std::string var_name;    
    std::fstream fix;  
    std::fstream var;  

    //------------------------------------------------- BankPartition_t --------
    BankPartition_t (Size_t buffer_size);


    //------------------------------------------------- BankPartition_t --------
    ~BankPartition_t ( );

  };


  //--------------------------------------------------- addPartition -----------
  void addPartition (bool create);


  //--------------------------------------------------- appendBID --------------
  void appendBID (IBankable_t & obj);


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


  //--------------------------------------------------- getPartition -----------
  BankPartition_t * getPartition (ID_t id)
  {
    if ( partitions_m [id] -> fix . is_open( ) )
      return partitions_m [id];
    else
      return openPartition (id);
  }


  //--------------------------------------------------- getLastPartition -------
  BankPartition_t * getLastPartition ( )
  {
    if ( partitions_m . back( ) -> fix . is_open( ) )
      return partitions_m . back( );
    else
      return openPartition (npartitions_m - 1);
  }


  //--------------------------------------------------- init -------------------
  void init ( );


  //--------------------------------------------------- localizeBID ------------
  BankPartition_t * localizeBID (ID_t & bid)
  {
    ID_t pid = (-- bid) / partition_size_m;
    bid -= pid * partition_size_m;
    return getPartition (pid);
  }


  //--------------------------------------------------- lockIFO ----------------
  void lockIFO ( );


  //--------------------------------------------------- openPartition ----------
  BankPartition_t * openPartition (ID_t id);


  //--------------------------------------------------- removeBID --------------
  void removeBID (ID_t bid);


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


  //----------------------------------------------------- setMode --------------
  void setMode (BankMode_t mode)
  {
    if ( mode & ~(B_READ | B_WRITE | B_SPY) )
      AMOS_THROW_ARGUMENT ("Invalid BankMode: unknown mode");

    if ( ! mode & (B_READ | B_WRITE | B_SPY) )
      AMOS_THROW_ARGUMENT ("Invalid BankMode: mode not specified");

    if ( mode & B_SPY )
      mode = B_SPY | B_READ;

      mode_m = mode;
  }


  //----------------------------------------------------- syncIFO --------------
  void syncIFO (IFOMode_t mode);


  //--------------------------------------------------- touchFile --------------
  void touchFile (const std::string & path, int mode, bool create);


  //--------------------------------------------------- unlockIFO --------------
  void unlockIFO ( );


  //--------------------------------------------------- Bank_t -----------------
  Bank_t (const Bank_t & source);


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


  NCode_t banktype_m;        

  Size_t buffer_size_m;      
  Size_t max_partitions_m;   

  bool is_open_m;            
  signed char status_m;      
  BankMode_t mode_m;         

  std::string store_dir_m;   
  std::string store_pfx_m;   
  Size_t fix_size_m;         
  Size_t partition_size_m;   

  ID_t last_bid_m;           
  ID_t max_bid_m;            
  ID_t nbids_m;              
  Size_t npartitions_m;      
  std::deque <BankPartition_t *> opened_m;      
  std::vector<BankPartition_t *> partitions_m;  

  IDMap_t idmap_m;           


public:

  typedef int64_t bankstreamoff;  

  static const std::string BANK_VERSION;      

  static const std::string IFO_STORE_SUFFIX;  
  static const std::string MAP_STORE_SUFFIX;  
  static const std::string LCK_STORE_SUFFIX;  

  static const std::string FIX_STORE_SUFFIX;  
  static const std::string VAR_STORE_SUFFIX;  

  static const std::string TMP_STORE_SUFFIX;  

  static const char WRITE_LOCK_CHAR;          
  static const char READ_LOCK_CHAR;           


  //--------------------------------------------------- Bank_t -----------------
  Bank_t (NCode_t type)
    : banktype_m (type),
      buffer_size_m (DEFAULT_BUFFER_SIZE),
      max_partitions_m (MAX_OPEN_PARTITIONS)
  {
    init( );
    status_m = 0;
  }


  //--------------------------------------------------- Bank_t -----------------
  Bank_t (const std::string & type)
    : banktype_m (Encode(type)),
      buffer_size_m (DEFAULT_BUFFER_SIZE),
      max_partitions_m (MAX_OPEN_PARTITIONS)
  {
    init( );
    status_m = 0;
  }


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


  //--------------------------------------------------- append -----------------
  void append (IBankable_t & 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 ( );


  //--------------------------------------------------- close ------------------
  void close ( );


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


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


  //--------------------------------------------------- destroy ----------------
  void destroy ( );


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


  //--------------------------------------------------- exists -----------------
  bool exists (const std::string & dir) const;


  //--------------------------------------------------- existsEID --------------
  bool existsEID (const std::string & eid) const
  {
    return (idmap_m . exists (eid));
  }


  //--------------------------------------------------- existsIID --------------
  bool existsIID (ID_t iid) const
  {
    return (idmap_m . exists (iid));
  }


  //--------------------------------------------------- fetch ------------------
  void fetch (ID_t iid, IBankable_t & obj)
  {
    fetchBID (lookupBID (iid), obj);
    obj . iid_m = iid;
    obj . eid_m . assign (idmap_m . lookupEID (iid));
  }


  //--------------------------------------------------- fetch ------------------
  void fetch (const std::string & eid, IBankable_t & obj)
  {
    fetchBID (lookupBID (eid), obj);
    obj . iid_m = idmap_m . lookupIID (eid);
    obj . eid_m . assign (eid);
  }


  //--------------------------------------------------- getIDMap ---------------
  const IDMap_t & getIDMap ( ) const
  {
    return idmap_m;
  }


  //--------------------------------------------------- getIDMapSize -----------
  Size_t getIDMapSize ( ) const
  {
    return idmap_m . getSize( );
  }


  //--------------------------------------------------- getIndexSize -----------
  Size_t getIndexSize ( ) const
  {
    return last_bid_m;
  }


  //--------------------------------------------------- getMaxIID --------------
  ID_t getMaxIID ( ) const;


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


  //--------------------------------------------------- getStatus --------------
  signed char getStatus ( ) const
  {
    return status_m;
  }


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


  //--------------------------------------------------- isOpen -----------------
  bool isOpen ( ) const
  {
    return is_open_m;
  }


  //--------------------------------------------------- lookupBID --------------
  ID_t lookupBID (ID_t iid) const;


  //--------------------------------------------------- lookupBID --------------
  ID_t lookupBID (const std::string & eid) const;


  //--------------------------------------------------- lookupEID --------------
  const std::string & lookupEID (ID_t iid) const
  {
    return idmap_m . lookupEID (iid);
  }


  //--------------------------------------------------- lookupIID --------------
  ID_t lookupIID (const std::string & eid) const
  {
    return idmap_m . lookupIID (eid);
  }


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


  //--------------------------------------------------- remove -----------------
  void remove (ID_t iid)
  {
    removeBID (lookupBID (iid));
    idmap_m . remove (iid);
  }


  //--------------------------------------------------- remove -----------------
  void remove (const std::string & eid)
  {
    removeBID (lookupBID (eid));
    idmap_m . remove (eid);
  }


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


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


  //--------------------------------------------------- setStatus --------------
  void setStatus (signed char status)
  {
    status_m = status;
  }

};


//--------------------------------------------------- BankExists ---------------
bool BankExists (NCode_t ncode, const std::string & dir);


//--------------------------------------------------- PrintBankVersion ---------
void PrintBankVersion (const char * s);

} // namespace AMOS

#endif // #ifndef __Bank_AMOS_HH

---