Table.h

Go to the documentation of this file.

#ifndef CARMA_SERVICES_TABLE_H
#define CARMA_SERVICES_TABLE_H

#include <iostream>
#include <iomanip>
#include <sstream>
#include <string>
#include <vector>

// For stat functions...
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>

namespace carma {
  namespace services {

    class Column {
    public:
      Column();
      ~Column();

      // by number (0..)
      Column(int column_number);
      // by fixed column width start..end (dangerious, TABs count as 1 character)
      Column(int start_column, int end_column);
      // special DMS or HMS access
      Column(int dcol, int mcol, int scol);
      // by name (NOT IMPLEMENTED YET)
      Column(std::string column_name);
    };


    class Table {
    public:

      Table();

      Table(const std::string& fileName, int maxRows=0);

      Table(int ncols);
      
      ~Table();
      

      void open(const std::string& fileName, int maxRows=0);


      struct stat status(const std::string & fileName );

      void reRead();

      bool hasBeenModified();

      void test(void);   // we don't want to advertise this :-)


      std::vector<std::string> getColumn(const std::string& column) const;

      std::vector<std::string> getColumn(const int column) const;

      std::vector<std::string> getColumn(const int col1, const int col2) const;

      std::vector<bool> getBoolColumn(const std::string& column) const;

      std::vector<bool> getBoolColumn(const int column) const;

      std::vector<bool> getBoolColumn(const int col1, const int col2) const;

      std::vector<double>      getDoubleColumn(const std::string& column) const;

      std::vector<double>      getDoubleColumn(const int column) const;

      std::vector<double>      getDoubleColumnAndVerify(const std::string& column) const;

      std::vector<double>      getDoubleColumnAndVerify(const int column) const;

      std::vector<double>      getDoubleColumn(const int col1, 
                                               const int col2) const;

      std::vector<int>         getIntColumn(const std::string& column) const;

      std::vector<int>         getIntColumn(const int column) const;

      std::vector<int>         getIntColumn(const int col1, 
                                            const int col2) const;

      std::vector<double>      getDMSColumn(const std::string& column) const;

      std::vector<double>      getDMSColumn(const int column) const;

      std::vector<double>      getDMSColumn(const std::string& hcolumn, const std::string& mcolumn, const std::string& scolumn) const;

      std::vector<double>      getDMSColumn(const int dcolumn, const int mcolumn, const int scolumn) const;

      std::vector<double>      getHMSColumn(const std::string& column) const;

      std::vector<double>      getHMSColumn(const int column) const;

      std::vector<double>      getHMSColumn(const std::string& hcolumn, const std::string& mcolumn, const std::string& scolumn) const;

      std::vector<double>      getHMSColumn(const int hcolumn, const int mcolumn, const int scolumn) const;


      std::vector<std::string> getCommentColumn(const std::string& column) const;
      std::vector<std::string> getCommentColumn(const int column) const;


      std::vector<double>      getDoubleRow(const int row) const;
      std::vector<int>         getIntRow(const int row) const;
      std::vector<std::string> getStringRow(const int row) const;

      std::string getRow(const int row) const;
      void putRow(const int row, const std::string& data);
      void addRow(const std::string& data);

      void removeRow(const int row);

      inline int getNrows(void) const { return nrows_; }
      inline int getNcols(void) const { return ncols_; }


      int getColumnNumber(const std::string& colname) const;

      std::string getColumnName(const int column=-1) const;      

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

      inline std::vector<std::string> getColumnUnits() const
      {
          return colunits_;
      }

      inline std::vector<std::string> getColumnTypes() const
      {
          return coltypes_;
      }

      std::string getColumnType(const int column=-1) const;      
      std::string getColumnUnit(const int column=-1) const;      

      void setColumnName(const int column, const std::string& name);
      void setColumnType(const int column, const std::string& name);
      void setColumnUnit(const int column, const std::string& name);

      int find(const std::string& query, 
          const int column = 0, 
          bool caseSensitive = false); 

      int find(const std::string& query, 
          const std::string& columnName,
          bool caseSensitive = false); 

      ::std::string getPathAndFileName() { return _filename; };

    private:
      // NOTE: If you add any private member variables, be sure
      // to also add them to Table::clear().
      int    ncols_;                         // number of columns
      int    nrows_;                         // number of rows
      std::vector<std::string> header_;      // header
      std::vector<std::string> data_;        // data

      std::vector<std::string> colnames_;    // column names (could be absent)
      std::vector<std::string> coltypes_;    // column types (could be absent)
      std::vector<std::string> colunits_;    // column units (could be absent)

      void clear( void );

      std::string word(const std::string& line, const int n, 
          const bool end=false) const;


      void Tokenize(const std::string& line, 
          std::vector<std::string>& tokens,
          const std::string& delimiters);

      int indexToken(const std::vector<std::string>& tokens, 
                     const std::string& name,
                     const bool single=true) const;
      bool CommentKey(const std::string& line, const std::string& key);

      /*
       *  convert a sexasegimal D:M:S string into D.ddd
       */
      double dms(const char *s) const;

      /*
       * convienence method for common error throwing pattern in this class
       */
      void throwBadColumnByNum( const int column ) const;

      /*
       * modification time at time of open
       */
      time_t _mtime;

      /*
       * local copy of opened filename
       */
      ::std::string _filename;
    };
  }
}


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


#endif  // CARMA_SERVICES_TABLE_H