ISTable.h

Go to the documentation of this file.

//$$FILE$$
//$$VERSION$$
//$$DATE$$
//$$LICENSE$$


#ifndef ISTABLE_H
#define ISTABLE_H


#include <float.h>

#include <string>
#include <vector>
#include <map>

#include "mapped_vector.h"
#include "mapped_vector.C"
#include "GenString.h"
#include "ITTable.h"
#include "Serializer.h"


using namespace std;


typedef multimap<string, unsigned int, StringCompare> tIndex;


class ISTable
{
  public:
    typedef ITTable::eOrientation eOrientation;

    static const eOrientation eCOLUMN_WISE = ITTable::eCOLUMN_WISE;
    static const eOrientation eROW_WISE = ITTable::eROW_WISE;

    enum eTableDiff
    {
        eNONE = 0,
        eCASE_SENSE,
        eMORE_COLS,
        eLESS_COLS,
        eCOL_NAMES,
        eMORE_ROWS,
        eLESS_ROWS,
        eCELLS,
        // Used only in block diff to indicate missing table in first block
        eMISSING,
        // Used only in block diff to indicate extra table in first block
        eEXTRA
    };

    typedef ITTable::eSearchType eSearchType;

    static const eSearchType eEQUAL = ITTable::eEQUAL;
    static const eSearchType eLESS_THAN = ITTable::eLESS_THAN;
    static const eSearchType eLESS_THAN_OR_EQUAL = ITTable::eLESS_THAN_OR_EQUAL;
    static const eSearchType eGREATER_THAN = ITTable::eGREATER_THAN;
    static const eSearchType eGREATER_THAN_OR_EQUAL = ITTable::eGREATER_THAN_OR_EQUAL;

#ifdef VLAD_SECOND_ITTABLE
    enum eSearchType
    {
        eEQUAL = 0,
        eLESS_THAN,
        eLESS_THAN_OR_EQUAL,
        eGREATER_THAN,
        eGREATER_THAN_OR_EQUAL
    };
#endif

    typedef ITTable::eSearchDir eSearchDir;

    static const eSearchDir eFORWARD = ITTable::eFORWARD;
    static const eSearchDir eBACKWARD = ITTable::eBACKWARD;

#ifdef VLAD_SECOND_ITTABLE
    enum eSearchDir
    {
        eFORWARD = 0,
        eBACKWARD
    };
#endif

    static const unsigned char DT_STRING_VAL = 1; 
    static const unsigned char DT_INTEGER_VAL = 2;
    // static const unsigned char DT_DOUBLE_VAL = 3;

    // Sets string comparison case sensitive
    static const unsigned char CASE_SENSE = 0x00;
    // Sets string comparison case insensitive
    static const unsigned char CASE_INSENSE = 0x01;
    // Sets string comparison to be sensitive to whitespace
    static const unsigned char W_SPACE_SENSE = 0x00;
    // Sets string comparison to ignore repeating whitspace.  
    // Also ignores leading and trailing whitespace
    static const unsigned char W_SPACE_INSENSE = 0x02;
    // string datatype
    static const unsigned char DT_STRING  = DT_STRING_VAL  << 4;
    // integer datatype
    static const unsigned char DT_INTEGER = DT_INTEGER_VAL << 4;
    // VLAD FEATURE NOT WORKING double is not working, maybe integer. check it      // double datatype
    // static const unsigned char DT_DOUBLE  = DT_DOUBLE_VAL  << 4;

    ISTable(const StringCompare::eCompareType colCaseSense =
      StringCompare::eCASE_SENSITIVE);

    ISTable(eOrientation orient, const StringCompare::eCompareType
      colCaseSense = StringCompare::eCASE_SENSITIVE);

    ISTable(const string& name,
      const StringCompare::eCompareType colCaseSense =
      StringCompare::eCASE_SENSITIVE);

    ISTable(const string& name, eOrientation orient,
      const StringCompare::eCompareType colCaseSense =
      StringCompare::eCASE_SENSITIVE);

    ISTable(const ISTable& inTable);

    ~ISTable();
 
    ISTable& operator=(const ISTable& inTable);

    eTableDiff operator==(ISTable& inTable);

    inline const string& GetName() const; 

    void SetName(const string& name);

    inline unsigned int GetNumColumns() const;

    const vector<string>& GetColumnNames() const;

    bool IsColumnPresent(const string& colName);

    void AddColumn(const string& colName, const vector<string>& col =
      vector<string> (0));

    void InsertColumn(const string& colName,
      const string& afColName, const vector<string>& col =
      vector<string> (0));

    void FillColumn(const string& colName, const vector<string>& col);

    void GetColumn(vector<string>& col, const string& colName);

    void GetColumn(vector<string>& col, const string& colName,
      const unsigned int fromRowIndex, unsigned int toRowIndex);

    void GetColumn(vector<string>& col, const string& colName,
      const vector<unsigned int>& rowIndex);

    void RenameColumn(const string& oldColName, const string& newColName);

    void ClearColumn(const string& colName);

    void DeleteColumn(const string& colName);

    inline unsigned int GetNumRows() const;

    unsigned int AddRow(const vector<string>& row = vector<string> (0));

    unsigned int InsertRow(const unsigned int atRowIndex,
      const vector<string>& row = vector<string> (0));

    void FillRow(const unsigned int rowIndex, const vector<string>& row);

    void GetRow(vector<string>& row, const unsigned int rowIndex,
      const string& fromColName = String::Empty, const string& toColName =
      String::Empty);

    const vector<string>& GetRow(const unsigned int rowIndex);

    void ClearRow(const unsigned int rowIndex);

    void DeleteRow(const unsigned int rowIndex);

    void DeleteRows(const vector<unsigned int>& rows);

    inline unsigned int GetLastRowIndex();

    void UpdateCell(const unsigned int rowIndex, const string& colName,
      const string& value);

    const string& operator()(const unsigned int rowIndex,
      const string& colName) const;

    void SetFlags(const string& colName, const unsigned char flags);

    unsigned char GetDataType(const string& colName);

    unsigned int FindFirst(const vector<string>& targets,
      const vector<string>& colNames,
      const string& indexName = String::Empty);

    void Search(vector<unsigned int>& res, const string& target,
      const string& colName, const unsigned int fromRowIndex = 0,
      const eSearchDir searchDir = eFORWARD,
      const eSearchType searchType = eEQUAL);

    void Search(vector<unsigned int>& res, const vector<string>& targets,
      const vector<string>& colNames, const unsigned int fromRowIndex = 0,
      const eSearchDir searchDir = eFORWARD,
      const eSearchType searchType = eEQUAL,
      const string& indexName = String::Empty);

    void FindDuplicateRows(vector<pair<unsigned int, unsigned int> >& duplRows,
      const vector<string>& colNames, const bool keepDuplRows,
      const eSearchDir searchDir = eFORWARD);

    inline StringCompare::eCompareType GetColCaseSense() const;

    inline void SetModified(const bool modified);

    inline bool GetModified();

    void SetSerializer(Serializer* ser);

    int WriteObject(Serializer* ser, int& size);

    int GetObject(UInt32 index, Serializer* ser);

    void Read(unsigned int indexInFile);

    int Write();

    // typeOfMerge is 0 for overwrite, 1 for overlap
    static ISTable* Merge(ISTable& firstTable, ISTable& secondTable,
      unsigned int typeOfMerge = 0); 

    bool PrintDiff(ISTable& inTable);

    inline bool IndexExists(const string& indexName);

    void CreateIndex(const string& indexName, const vector<string>& colNames,
      const unsigned int unique = 0);

    void UpdateIndex(const string& indexName, const unsigned int rowIndex);

    void RebuildIndex(const string& indexName);

    void RebuildIndices();

    void DeleteIndex(const string& indexName);

    inline unsigned int GetNumIndices();

    void CreateKey(const vector<string>& colNames);

    void DeleteKey();

    static void SetUnion(const vector<unsigned int>& a,
      const vector<unsigned int>& b, vector<unsigned int>& ret);

    static void SetIntersect(const vector<unsigned int>& a,
      const vector<unsigned int>& b, vector<unsigned int>& ret);

    void GetColumnsIndices(vector<unsigned int>& colIndices,
      const vector<string>& colNames);

    void GetColumn(vector<string>& col, const string& colName,
      const string& indexName);

  private:
    static const unsigned int MAX_NUM_ITTABLE_ROWS = 1000;

    // number of digit DBL_MIN_10_EXP, letter e is not included in size
    static const unsigned int EXPONENT      =  4;
    static const unsigned int MAX_PRECISION = DBL_DIG;
    //???DBL_MANT_DIG;
    static const unsigned int MANTISSA       =  MAX_PRECISION + 2;
    static const unsigned int INT_LIMIT      = 11;

    // datatype mask
    static const unsigned char DT_MASK        = 15 << 4;
    // string comparison sensitivity mask
    static const unsigned char SC_MASK        = 0x01;
    // white space sensitivity mask
    static const unsigned char WS_MASK        = 0x02;
    static const unsigned char LAST_DT_VALUE  = 3;
    static const unsigned int  DEFAULT_PRECISION = MAX_PRECISION;
    static const unsigned char DEFAULT_OPTIONS;

    static const string _version;

    string _name;

    vector<ITTable> _ittables;

    ITTable::eOrientation _orient;

    StringCompare::eCompareType _colCaseSense;

    mapped_vector<string, StringCompare> _colNames;
 
    vector<unsigned int> _precision;
    vector<unsigned char> _compare_opts;

    vector<string> _indexNames;
    vector<vector<unsigned int> > _listsOfColumns;
    vector<unsigned int> _unique;

    Serializer* _ser;

    bool _modified; // Indicates whether table has been modified

    unsigned int _numRows;

    mutable unsigned int _rowIndexCache;
    mutable pair<unsigned int, unsigned int> _rowLocCache;

    void InsertColumn(const string& colName, const unsigned int atColIndex,
      const vector<string>& col = vector<string> (0));
    void CreateColumn(const string& colName, const unsigned int atColIndex,
      const vector<string>& col = vector<string> (0));
    int UpdateCell(const string& cell, const unsigned int colIndex,
      const unsigned int rowIndex);
    const string& operator()(const unsigned int rowIndex,
      const unsigned int colIndex) const;
    int SetFlags(const unsigned char newOpts, const unsigned int colIndex);
    void FindDuplicateRows(const vector<unsigned int>& colIndices,
      vector<pair<unsigned int, unsigned int> >& duplRows,
      const unsigned int keep, const eSearchDir searchDir = eFORWARD);
    void VerifyColumnsIndices(const vector<unsigned int>& colIndices);
    bool AreListsOfColumnsValid(const vector<unsigned int>& colIndices);
    void CreateIndex(const string& indexName,
      const vector<unsigned int>& colIndices, const unsigned int unique = 0);
    void CreateKey(const vector<unsigned int>& colIndices);
    unsigned int FindFirst(const vector<string>& targets,
      const vector<unsigned int>& colIndices,
      const string& indexName = String::Empty);
    void Search(vector<unsigned int>& res, const vector<string>& targets,
      const vector<unsigned int>& colIndices,
      const unsigned int fromRowIndex = 0,
      const eSearchDir searchDir = eFORWARD,
      const eSearchType searchType = eEQUAL,
      const string& indexName = String::Empty);

    void Init();
    void Clear();

    StringCompare::eCompareType
      GetCompareType(const vector<unsigned int>& colIndices);

    string CellValue(const unsigned int colIndex,
      const unsigned int rowIndex);
    string ConvertString(const string& value, const unsigned int colIndex);
    string MultiStringsValue(const vector<string>& values,
      const vector<unsigned int>& colIndices);
    string SubRowValue(const vector<unsigned int>& colIndices,
      const unsigned int rowIndex);
    string AggregateRow(const vector<unsigned int>& colIndices,
      const unsigned int rowIndex);

    inline void AppendToAndDelimit(string& to, const string& appending);

    void ValidateOptions(unsigned int colIndex);

    string CreateInternalIndexName(const unsigned int indexIndex);
    void UpdateIndex(const unsigned int indexIndex,
      const unsigned int rowIndex);
    void RebuildIndex(const unsigned int indexIndex);
    void ClearIndex(const unsigned int indexIndex);
    void DeleteIndex(const unsigned int indexIndex);

    int FindIndex(const string& indexName);
    int FindIndex(const vector<unsigned int>& colIndices);

    void UpdateIndices(const unsigned int rowIndex);
    void ClearIndices();

    bool IsColumnInIndex(const unsigned int indexIndex,
      const unsigned int colIndex);

    int FindKeyIndex();

    void UpdateColListOnColInsert(const unsigned int colIndex);
    void UpdateColListOnColDelete(const unsigned int colIndex);
    void UpdateColListOnCellUpdate(const unsigned int rowIndex,
      const unsigned int colIndex);

    unsigned int FindFirst(const vector<string>& targets,
      const vector<unsigned int>& colIndices, const unsigned int indexIndex);

    int WriteObjectV9(Serializer*, int& size);

    int GetObjectV9(UInt32 index, Serializer*);
    int GetObjectV8(UInt32 index, Serializer*);
    int GetObjectV7(UInt32 index, Serializer*);
    int GetObjectV6(UInt32 index, Serializer*);
    int GetObjectV3(UInt32 index, Serializer*);
    int GetObjectV2(UInt32 index, Serializer*);
    int GetObjectV1(UInt32 index, Serializer*);
    int GetObjectV1_1(UInt32 index, Serializer*);

    void ConvertToInt(const string& a, string& ret);
    void ConvertDouble(const string& a, string& ret);
    void ConvertToLowerNoWhiteSpace(const string& a, string& ret);

    void GetRowLocation(pair<unsigned int, unsigned int>& rowLoc,
      const unsigned int rowIndex) const;
    void CacheRowLocation(const unsigned int rowIndex) const;

    void CreateSubtables(const unsigned int numRows);
    void CreateSubtableColumns(const unsigned int colIndex,
      const vector<string>& col);
    void CreateColumn(const unsigned int atColIndex,
      const vector<string>& col);

    void Print(const string& indexName);

    unsigned int GetColumnIndex(const string& colName) const;

};


ostream& operator<<(ostream& out, const ISTable& isTable);


inline unsigned int ISTable::GetLastRowIndex()
{

    return(GetNumRows() - 1);

}


inline unsigned int ISTable::GetNumIndices()
{

    return(_indexNames.size());

}


inline bool ISTable::IndexExists(const string& indexName)
{

    int ret = FindIndex(indexName);

    if (ret == -1)
    {
        return(false);
    }
    else
    {
        return(true);
    }

}


inline void ISTable::AppendToAndDelimit(string& to, const string& appending)
{

    to += appending;
    // VLAD HARDCODED CONST
    to += " ";

}


inline void ISTable::SetModified(const bool modified)
{
    _modified = modified;
}


inline bool ISTable::GetModified()
{
    return _modified;
}


inline const string& ISTable::GetName() const
{
    return(_name);
}


inline unsigned int ISTable::GetNumRows() const
{
    return(_numRows);
}


inline unsigned int ISTable::GetNumColumns() const
{
    return(_colNames.size());
}


inline StringCompare::eCompareType ISTable::GetColCaseSense() const
{
    return(_colCaseSense);
}


#endif // ISTABLE_H

---