/home/bes3soft/bes3soft/Boss/7.0.2/dist/7.0.2/Calibration/rdbModel/rdbModel-00-01-01/rdbModel/Rdb.h

Go to the documentation of this file.

// $Header: /bes/bes/BossCvs/Calibration/rdbModel/rdbModel/Rdb.h,v 1.1.1.1 2005/10/17 06:10:53 maqm Exp $
#ifndef RDBMODEL_RDB_H
#define RDBMODEL_RDB_H
#include <vector>
#include <string>
// #include "detModel/Sections/Section.h"

#include "rdbModel/Management/Visitor.h"

namespace rdbModel {
  
  class Table;
  class Column;
  class Index;
  //  class Assertion;
  class XercesBuilder;
  class Connection;
  class Row;

    // Values for database fields may be specified in various ways
  enum FIELDTYPE {
    FIELDTYPElit = 0,  // literal value
    FIELDTYPEold,      // col name, refers to (value of) col in existing row
    FIELDTYPEtoBe,     // col name, refers to (value of) col in proposed row
    FIELDTYPEask,       // supply value at the time of the operation
    FIELDTYPElitDef,   // literal but may be overridden
    FIELDTYPEoldDef,   // comes from existing row, may be overridden
    FIELDTYPEtoBeDef  // comes from proposed row, may be overridden
  };

  class Rdb {    
  public:
    virtual ~Rdb();
    Rdb() : m_connection(0) { }


    unsigned getMajorVersion(){return m_majorVersion;};
    unsigned getMinorVersion(){return m_minorVersion;};

    const std::string& getCVSid(){return m_CVSid;};

    const std::string& getDbName(){return m_dbName;};
    // Not sure we want to expose this:
    // This method gives back a pointer to the tables vector
    //    std::vector <Table*>  getTables(){return m_tables;};  

    Table* getTable(const std::string& name) const;
    Column* getColumn(const std::string& tableName, 
                      const std::string& colName) const;

    Index* getIndex(const std::string& tableName, 
                      const std::string& indexName) const;

    unsigned int getNTable() const {return m_tables.size();}

    // Do we want an unset as well?  Or just call this with arg == 0 ?
    void setConnection(Connection* connection);

    int insertRow(const std::string& tName, Row& row, int* serial=0) const;

    int insertLatest(Table* t, Row& row, int* serial=0) const;
    int insertLatest(const std::string& tName, Row& row, int* serial=0) const;

    int supersedeRow(const std::string& tName, Row& row, int oldKey, 
                     int* newKey=0) const;

    int updateRows(const std::string& tName, Row& row, Assertion* where) const;


    unsigned int  accept(Visitor* v);
    // This is the non recursive accept for the visitor pattern
    // Not yet sure we need it
    //    Visitor::VisitorState acceptNotRec(Visitor* v);

    // This method builds a global volumes map for all the sections 
    //    void buildVolumeMap();
    // This method builds the global constants maps for all the constants
    //void buildConstantsMap();

  private:
    // Must make each concrete implementation of Builder a friend since
    // derived classes don't inherit friendliness.
    friend class rdbModel::XercesBuilder;

    //    void setDTDversion(std::string pdtd){m_DTDversion = pdtd;};
    void setCVSid(std::string pcvs){m_CVSid = pcvs;};

    void addTable(Table* t){m_tables.push_back(t);};

    // Maybe have private table map to support look-up by name?
    // Or maybe don't bother.  The target application will have
    // a very small number of tables, so a linear search is
    // perfectly ok.

    std::vector<Table* > m_tables;  
  
    std::string m_dbName;
    unsigned m_majorVersion;
    unsigned m_minorVersion;
    //    std::string m_DTDversion;
    std::string m_CVSid;
    Connection* m_connection;

  };
}

#endif //RDB_H

---