GloriaFitsTable.h

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


#ifndef GloriaFitsTable_h
#define GloriaFitsTable_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 "GloriaFitsHeader.h"
#include "GloriaTableColumn.h"

using namespace std;

namespace gloria{


  class GloriaFitsTable : public GloriaFitsHeader {

  public:


    GloriaFitsTable();

    /* Creates empty table and reads its contents from the fits file */
    GloriaFitsTable(string FitsFileName);

    GloriaFitsTable(const GloriaFitsTable& sourceFitsTable);

    virtual ~GloriaFitsTable();

    GloriaFitsTable& operator= (const GloriaFitsTable& tab);


    void ReadFitsFile(string FitsFileName);


    void ReadTextFile(string TextFileName);


    void WriteFitsFile(string FitsFileName, bool binary_tbl=true);


    void WriteTextFile(string TextFileName, int colWidth=10, char ColumnSeparator = ' ');


    void WriteTextStream(std::ostream& outF, int colWidth=10, char ColumnSeparator = ' ');


    // Data access methods
    // ===================

    inline int GetColumnNumber() {return _nColumn;};

    inline int GetRowNumber() {return _nRow;};

    inline string GetColumnName(int iCol) 
               {return _columns.at(iCol)->Name();};

    inline int GetColumnId(string name) 
               {return _nameMap.find(name)->second; };

    inline TableColumnType GetColumnType(int iCol)
               {return _columns.at(iCol)->Type(); };

    inline TableColumnType GetColumnType(string name)
               {return _columns.at(_nameMap.find(name)->second)->Type(); };


    inline bool ColumnExists(string name)
               {return _nameMap.find(name)!=_nameMap.end();};

     inline GloriaTableColumn* GetColumn(int iCol)
               {return _columns.at(iCol); } ;

     inline GloriaTableColumn* GetColumn(string name)
               {return _columns.at(_nameMap.find(name)->second); } ;

     /* This method DOES NOT check consistency of types nor indexes - be careful */
     template <class T>
     inline GloriaTableColumnOf<T>* GetColumnOf(int iCol)
               {return (GloriaTableColumnOf<T> *)_columns.at(iCol); } ;

     /* This method DOES NOT check consistency of types nor indexes - be careful */
     template <class T>
     inline GloriaTableColumnOf<T>* GetColumnOf(string name)
             {return (GloriaTableColumnOf<T> *)_columns.at(_nameMap.find(name)->second); } ;

     /* This method DOES NOT check consistency of types nor indexes - be careful */
     template <class T>
     inline vector<T>& GetVectorOf(int iCol) 
             { return ((GloriaTableColumnOf<T> *)_columns.at(iCol))->Data(); };


     /* This method DOES NOT check consistency of types nor indexes - be careful */
     template <class T>
     inline vector<T>& GetVectorOf(string name) 
             { return ((GloriaTableColumnOf<T> *)_columns.at(_nameMap.find(name)->second))->Data(); };


     /* This method DOES NOT check consistency of types nor indexes - be careful */
     template <class T>
     inline T& GetValueOf(int iCol, int iRow) 
             { return ((GloriaTableColumnOf<T> *)_columns.at(iCol))->At(iRow); };


     /* This method DOES NOT check consistency of types nor indexes - be careful */
     template <class T>
     inline T& GetValueOf(string name, int iRow) 
            { return ((GloriaTableColumnOf<T> *)_columns.at(_nameMap.find(name)->second))->At(iRow); };



    void AddColumn(string Name, TableColumnType Type, string Unit = "" , string Comment = "" );



    template <class T>
    void AddColumn(string Name, T empty, string Unit = "" , string Comment = "" );


    void InsertColumn(GloriaTableColumn* source);


    void InsertColumn(string NewName, GloriaTableColumn* source);


    void AddRow();



    template <class T>
    inline void AddRow(T val){ AddRow(); SetLast(0,val); };


    template <class T0, class T1>
    inline void AddRow(T0 val0, T1 val1){ AddRow(); SetLast(0,val0); SetLast(1,val1);};



    template <class T0, class T1, class T2>
    inline void AddRow(T0 val0, T1 val1, T2 val2){ AddRow(); SetLast(0,val0); SetLast(1,val1); SetLast(2,val2);};


    template <class T0, class T1, class T2, class T3>
    inline void AddRow(T0 val0, T1 val1, T2 val2, T3 val3)
                { AddRow(); SetLast(0,val0); SetLast(1,val1); SetLast(2,val2);SetLast(3,val3);};


    template <class T0, class T1, class T2, class T3, class T4>
    inline void AddRow(T0 val0, T1 val1, T2 val2, T3 val3, T4 val4)
                { AddRow(); SetLast(0,val0); SetLast(1,val1); SetLast(2,val2);SetLast(3,val3);SetLast(4,val4);};

    /* This method checks consistency of variable and column types */
    template <class T>
    void SetValue(string Name, int iRow, T val);


    /* This method checks consistency of variable and column types */
    template <class T>
    void SetValue(int iCol, int iRow, T val);


    /* This method checks consistency of variable and column types */
    template <class T>
    void SetLast(int iCol, T val);

    /* This method checks consistency of variable and column types */
    template <class T>
    void SetLast(string Name, T val);

    /* This method checks consistency of variable and column types */
    template <class T>
    void GetValue(string Name, int iRow, T* val);

    /* This method checks consistency of variable and column types */
    template <class T>
    void GetValue(int iCol, int iRow, T* val);


    void CopyTableRow(GloriaFitsTable* source, int isource, int itarget=-1);

    GloriaFitsTable* EmptyClone();

    void AdjustColumns();

    bool CheckTable();


    long* CreateSortIndex(int iCol, bool reverse=false);

    long* CreateSortIndex(string name, bool reverse=false);

    void  SortTable(int iCol, bool reverse=false);

    void  SortTable(string name, bool reverse=false);


    inline bool IsSorted() { return  (_nSorted == _nRow); } ;

    inline bool IsSortedBy(string name) 
              { return  (_nSorted == _nRow  && name == _sortName); } ;

    inline string SortName() { return  _sortName; } ;

    inline int SortColumn() { return  _sortColumn; } ;

    void DeleteRow(int iRow);

    GloriaTableColumn* RemoveColumn(int iCol);

    GloriaTableColumn* RemoveColumn(string name);

    void DeleteColumn(int iCol);

    void DeleteColumn(string name);

    void ClearTable();

    void EmptyTable();

    /* Column width can be set between 3 and 20 characters */

    void Print( std::ostream& os, int colWidth=10);

protected:

    void InitializeEmptyTable();

   
    int _nRow, _nColumn;

    vector<GloriaTableColumn* > _columns;

    multimap< string, int > _nameMap;

    int _nSorted;

    string _sortName;

    int _sortColumn;

  } ;


}

#endif