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

Go to the documentation of this file.

// $Header: /bes/bes/BossCvs/Calibration/rdbModel/rdbModel/Tables/Column.h,v 1.1.1.1 2005/10/17 06:10:53 maqm Exp $
#ifndef RDBMODEL_COLUMN_H
#define RDBMODEL_COLUMN_H
#include <vector>
#include <string>
#include <utility>
#include "rdbModel/Management/Visitor.h"
// #include "rdbModel/Tables/Table.h"

namespace rdbModel {

  //  class Table;
  class Datatype;
  class Enum;
  class Table;
  class XercesBuilder;



  class Column {
    //    class ColumnSource;      // embedded class, described below

  public:
    enum FROM {
      FROMdefault = 1,          // enduser can override default, however
      FROMautoIncrement,
      FROMnow,                  // datatype must be timestamp - deprecated
      FROMprogram,
      FROMendUser
    };

    enum CONTENTS {
      CONTENTSunspecified = 0,
      CONTENTSserviceName = 1,
      CONTENTSusername    = 2,
      CONTENTSinsertTime   = 3,
      CONTENTSupdateTime = 4

    };

    Column(Table* myTable=0) : m_myTable(myTable), m_type(0), 
                               m_isPrimaryKey(false) {
      m_contents = CONTENTSunspecified;
      m_default = std::string("");};
    // Column(Table* myTable=0) : m_myTable(myTable), m_type(0), m_source(0) {};
    ~Column();


    const std::string& getName() const {return m_name; };
    const std::string& getComment() const {return m_comment;};

    const std::string& getDefault() const {return m_default;}

    const std::string& getTableName() const;

    Datatype* getDatatype() const {return m_type;};

    Enum* getEnum() const;

    bool okValue(const std::string& val, bool set=true) const;

    bool isCompatible(const Column* otherCol) const;

    bool nullAllowed() const { return m_null;}
   
    bool stickyInsert() const { return m_stickyInsert;}

    bool isPrimaryKey() const {return m_isPrimaryKey;}

    bool isAutoIncrement() const;  

    FROM getSourceType() const {return m_from;}
    CONTENTS getContentsType() const {return m_contents;}

    bool interpret(const std::string& interpType, std::string&val);
                               
    Visitor::VisitorState accept(Visitor* v);

  private:
    friend class rdbModel::XercesBuilder; // needs access to add.. methods 

    Table* m_myTable;

    std::string m_name;
    std::string m_comment;
    Datatype*  m_type;
      
    std::string m_default;
    FROM m_from;
    CONTENTS m_contents;

    bool m_null;
    bool m_stickyInsert;  
    
    bool m_isPrimaryKey;

  };

  // Do we want Column* for first component or just the column name?
  class FieldVal {
    //    Column* m_pCol;
  public:
    FieldVal(std::string colname, std::string val, bool isNull=false) :
      m_colname(colname), m_val(val), m_null(isNull) { }
    std::string m_colname;
    std::string m_val;
    bool        m_null; // true if field val is NULL; then will ignore m_val
  };

  class FieldValCompare {
  public:
    //    bool operator()  (const Column* a, const Column*  b) {
    bool operator()  (const FieldVal& a, const FieldVal&  b) {
      return ((a.m_colname).compare(b.m_colname) < 0);
      //      return (a.first->getName().compare(b.first->getName()) < 0);
    }
  };

  class Row {
  public:
    Row() : m_sorted(false) {m_fields.clear();}
    Row(std::vector<FieldVal>& fields) : m_fields(fields), m_sorted(false) {}

    ~Row() { m_fields.clear(); }
    void rowSort();
    void addField(const FieldVal& f) {m_fields.push_back(f); m_sorted = false;}
    void clear() {m_fields.clear();}

    FieldVal* find(std::string colname);

    void  regroup(std::vector<std::string>& colNames, 
                  std::vector<std::string>& colVals, 
                  std::vector<std::string>& nullCols) const;
  private:
    std::vector<FieldVal> m_fields;
    bool     m_sorted;
  };
}
#endif

---