Table.h

Go to the documentation of this file.

#ifndef CARMA_DBMS_TABLE_H
#define CARMA_DBMS_TABLE_H

#include "carma/dbms/Column.h"
#include <map>
#include <string>
#include <vector>

namespace carma {
namespace dbms {

class Table {

public:
    typedef enum {
        INT_COLUMN_TYPE,
        SHORT_COLUMN_TYPE,
        FLOAT_COLUMN_TYPE,
        DOUBLE_COLUMN_TYPE,
        STRING_COLUMN_TYPE,
        BIGINT_COLUMN_TYPE,
        DECIMAL_COLUMN_TYPE
    } ColumnType;


    Table();

    Table(const std::string& name);

    ~Table();

    inline std::string getName() const {return name_;}

    void setName(const std::string& name) {name_ = name;}

    inline unsigned columnCount() const {return indicesVector_.size();}

    inline unsigned rowCount() const {return nRows_;}

    template<typename T> 
      void addColumn(const Column<T> &col);

    void addBigIntColumn(const Column<long long>& col);

    void addDoubleColumn(const Column<double>& col);
    
    void addFloatColumn(const Column<float>& col);

    void addIntColumn(const Column<int>& col);

    void addShortColumn(const Column<short>& col);

    void addStringColumn(const Column<std::string>& col);

    void addDecimalColumn(const Column<std::string>& col);

    template<typename T>
      carma::dbms::Column<T> getColumn(const unsigned &index) const;

    template<typename T>
      carma::dbms::Column<T> getColumn(const std::string &columnName) const;

    carma::dbms::Column<long long> getBigIntColumn(const unsigned& index) const;

    carma::dbms::Column<long long> getBigIntColumn
        (const std::string& columnName) const;

    carma::dbms::Column<double> getDoubleColumn(const unsigned& index) const;

    carma::dbms::Column<double> getDoubleColumn(const std::string& columnName) 
        const;

    carma::dbms::Column<float> getFloatColumn(const unsigned& index) const;

    carma::dbms::Column<float> getFloatColumn(const std::string& columnName) 
        const;

    carma::dbms::Column<int> getIntColumn(const unsigned& index) const;

    carma::dbms::Column<int> getIntColumn(const std::string& columnName) 
        const;

    carma::dbms::Column<short> getShortColumn(const unsigned& index) const;

    carma::dbms::Column<short> getShortColumn(const std::string& columnName) 
        const;

    carma::dbms::Column<std::string> getStringColumn(const unsigned& index) const;

    carma::dbms::Column<std::string> getStringColumn
        (const std::string& columnName) const;

    carma::dbms::Column<std::string> getDecimalColumn(const unsigned& index) const;

    carma::dbms::Column<std::string> getDecimalColumn
        (const std::string& columnName) const;

    inline std::vector< ColumnType > getColumnTypes() const {
        return colTypesVector_;
    }

    std::vector<std::string> getColumnNames() const { return colNames_; }

    std::string toString() const;

    static std::string columnType2String(const ColumnType & ctype);

    carma::dbms::Table createSubTable
        (const std::vector<std::string>& colNames,
         const std::string& tableName="subtable") const;

protected:
    // add other column types as necesary

    std::vector<carma::dbms::Column<long long> > bigIntColumns_;
    std::vector<carma::dbms::Column<double> > doubleColumns_;
    std::vector<carma::dbms::Column<float> > floatColumns_;
    std::vector<carma::dbms::Column<int> > intColumns_;
    std::vector<carma::dbms::Column<std::string> > stringColumns_;
    // Decimals are implemented as strings.
    std::vector<carma::dbms::Column<std::string> > decimalColumns_;
    std::vector<carma::dbms::Column<short> > shortColumns_;

    std::vector<int> indicesVector_;
    std::vector< ColumnType > colTypesVector_;
    std::map<std::string, unsigned> colNames2Indices_;
    std::vector<std::string> colNames_;
    std::string name_;
    unsigned nRows_;

    void addNewColumn_(const unsigned int& columnSize, 
                       const std::string& columnName);

    void getColumn_(const unsigned& index, const ColumnType & colType) const;


    void getColumn_(const std::string& columnName) const;

 private:
    template<typename T>
      int addElementsToPrivateColumns(const Column<T> &col);
    
    template<typename T>
      Column<T> getPrivateColumn(const unsigned &index) const;

};

 /* default instantiation for type not specified below */
 template < typename T >
 inline int
 Table::addElementsToPrivateColumns( const Column< T > & col ) {
    // Deliberately cause a compile-time error if code tries to use this
    // "generic" version of the template
    
    struct we_should_not_be_here;

    if ( sizeof( we_should_not_be_here ) != 3 )
        throw -11;
    
    return 0;
 }

 /* instantiations of specified templates for adding elements to
    columns */
 template<>
   inline int Table::addElementsToPrivateColumns<int>(const Column<int> &col) {
   intColumns_.push_back(col);
   colTypesVector_.push_back(Table::INT_COLUMN_TYPE);
   return intColumns_.size();
 }

 template<>
   inline int Table::addElementsToPrivateColumns<float>(const Column<float> &col) {
   floatColumns_.push_back(col);
   colTypesVector_.push_back(Table::FLOAT_COLUMN_TYPE);
   return floatColumns_.size();
 }

 template<>
   inline int Table::addElementsToPrivateColumns<long long>(const Column<long long> &col) {
   bigIntColumns_.push_back(col);
   colTypesVector_.push_back(Table::BIGINT_COLUMN_TYPE);
   return bigIntColumns_.size();
 }

 template<>
   inline int Table::addElementsToPrivateColumns<double>(const Column<double> &col) {
   doubleColumns_.push_back(col);
   colTypesVector_.push_back(Table::DOUBLE_COLUMN_TYPE);
   return doubleColumns_.size();
 }

 template<>
   inline int Table::addElementsToPrivateColumns<short>(const Column<short> &col) {
   shortColumns_.push_back(col);
   colTypesVector_.push_back(Table::SHORT_COLUMN_TYPE);
   return shortColumns_.size();
 }

 template<>
   inline int Table::addElementsToPrivateColumns<std::string>(const Column<std::string> &col) {
   stringColumns_.push_back(col);
   colTypesVector_.push_back(Table::STRING_COLUMN_TYPE);
   return stringColumns_.size();
 }

 /* end instantiations of templates for adding elements to columns */


 /* template instantiation for adding a Column to the Table */
 template<typename T> 
   inline void Table::addColumn(const Column<T> &col) {
   addNewColumn_(col.size(), col.getName());
   int nElements = addElementsToPrivateColumns<T>(col);
   indicesVector_.push_back(nElements-1);
   colNames2Indices_[col.getName()] = indicesVector_.size()-1;
   colNames_.push_back(col.getName());
   nRows_ = col.size();
 }


 /* default instantiation of template for getting private column of
    type not specified below */
 template < typename T >
 inline Column< T >
 Table::getPrivateColumn( const unsigned & index ) const {
    // Deliberately cause a compile-time error if code tries to use this
    // "generic" version of the template
    
    struct we_should_not_be_here;

    if ( sizeof( we_should_not_be_here ) != 3 )
        throw -13;
    
    return Column< T >( );
 }

 /* instantiations for specific templates for getting columns of a
    specific type */
 template<>
 inline Column<long long>
 Table::getPrivateColumn<long long>(const unsigned &index) const {
   getColumn_(index, Table::BIGINT_COLUMN_TYPE);
   return bigIntColumns_[indicesVector_[index]];
 }

 template<>
 inline Column<double>
 Table::getPrivateColumn<double>(const unsigned &index) const {
   getColumn_(index, Table::DOUBLE_COLUMN_TYPE);
   return doubleColumns_[indicesVector_[index]];
 }

 template<>
 inline Column<float>
 Table::getPrivateColumn<float>(const unsigned &index) const {
   getColumn_(index, Table::FLOAT_COLUMN_TYPE);
   return floatColumns_[indicesVector_[index]];
 }

 template<>
 inline Column<int>
 Table::getPrivateColumn<int>(const unsigned &index) const {
   getColumn_(index, Table::INT_COLUMN_TYPE);
   return intColumns_[indicesVector_[index]];
 }

 template<>
 inline Column<short>
 Table::getPrivateColumn<short>(const unsigned &index) const {
   getColumn_(index, Table::SHORT_COLUMN_TYPE);
   return shortColumns_[indicesVector_[index]];
 }

 template<>
 inline Column<std::string>
 Table::getPrivateColumn<std::string>(const unsigned &index) const {
   getColumn_(index, Table::STRING_COLUMN_TYPE);
   return stringColumns_[indicesVector_[index]];
 }

 /* end instantiations for getting columns of a specific type */

 /* instantiation for template that gets a column from a name */
 template<typename T>
 inline carma::dbms::Column<T>
 Table::getColumn(const std::string &columnName) const {
   getColumn_(columnName);
   return getColumn<T>((colNames2Indices_.find(columnName))->second);
 }

 /* instantiation for template that gets a column from an index */
 template<typename T>
 inline carma::dbms::Column<T>
 Table::getColumn(const unsigned &index) const {
   return getPrivateColumn<T>(index);
 }

}}

 std::ostream & operator<<( ::std::ostream &           os,
                            const carma::dbms::Table & table );

#endif // CARMA_DBMS_TABLE_H