GloriaTableColumn.h

// -*- mode: c++; mode: auto-fill; mode: flyspell-prog; -*-


#ifndef GloriaTableColumn_h
#define GloriaTableColumn_h 1


/*
 *   This source code is part of the LUIZA software package for GLORIA.
 *   You are free to use this source files for your own development as
 *   long as it stays in a public research context. You are not
 *   allowed to use it for commercial purpose. You must put this
 *   header with author names in all development based on this file.
 *
 */

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

#include "GloriaSTLTypes.h"

using namespace std;

namespace gloria{



  enum TableColumnType
      { UndefinedColumn = 0,
      LongColumn,
      DoubleColumn,
      StringColumn,
      LongVectorColumn,
      DoubleVectorColumn
      };


template<class T> 
TableColumnType GetValueType(T val);


template<class T> 
string GetValueTypeName(T val);



class GloriaTableColumn {

public: 

  GloriaTableColumn(string Name, string Unit = "", string Comment = "") : 
                         _name(Name), _unit(Unit), _comment(Comment){}

  inline virtual ~GloriaTableColumn() {}

  inline string& Name() { return _name; }

  inline string& Unit() { return _unit; }

  inline string& Comment() { return _comment; }

  inline TableColumnType& Type() { return _type; }

  string TypeName(); 

  virtual int Size() = 0;

  virtual void Clear() = 0;

  virtual void AddRow() = 0;

  virtual void Resize(int Nrow) = 0;

  virtual void DeleteRow(int iRow) = 0;


  virtual int ValSize(int i) = 0;


  virtual long LongVal(int i, int j=0) = 0;


  virtual double DoubleVal(int i, int j=0) = 0;


  virtual string StringVal(int i) = 0;


  virtual string StringVal(int i, int j) = 0;


  virtual GloriaTableColumn* Clone() = 0;


  virtual GloriaTableColumn* EmptyClone() = 0;


  virtual void CopyCellValue(GloriaTableColumn* source, int isource, int itarget=-1) = 0;

  
  virtual long* CreateSortIndex(bool reverse=false) = 0;
  
  virtual void SortByIndex(long* index) = 0;
  
protected:
  string _name;
  string _unit;
  string _comment;
  TableColumnType _type;
};      



template <class T>
class GloriaTableColumnOf : public GloriaTableColumn {

public:
  GloriaTableColumnOf(string Name, T empty, string Unit = "", string Comment = "") : 
         GloriaTableColumn(Name,Unit,Comment), _emptyVal(empty) 
                                { _type = GetValueType(empty); }

  inline  ~GloriaTableColumnOf() {}

  inline vector<T>& Data() { return _data;}

  inline T& At(int i) { return _data.at(i); }

  inline T& EmptyVal() { return _emptyVal; }

  inline int Size() { return _data.size(); }

  inline void Clear() {  _data.clear(); }

  inline void Push_Back(T val) { _data.push_back(val); }

  inline void AddRow() { _data.push_back(_emptyVal); }

  inline void Resize(int Nrow){_data.resize(Nrow,_emptyVal); }

  inline void DeleteRow(int iRow) { _data.erase(_data.begin()+iRow); }



  int ValSize(int i);



  long LongVal(int i, int j=0);



  double DoubleVal(int i, int j=0);



  string StringVal(int i);


  string StringVal(int i, int j);

  GloriaTableColumn* Clone();

  GloriaTableColumn* EmptyClone();

  void CopyCellValue(GloriaTableColumn* source, int isource, int itarget=-1);

  long* CreateSortIndex(bool reverse=false);
  
  void SortByIndex(long* index);
  
protected:

  T _emptyVal;
  vector<T> _data;
};



}

#endif