TableData.hxx

Go to the documentation of this file.

//-----------------------------------------------------------------------------
// CVS: $Revision: 6421 $, $Date: 2009-11-27 10:57:35 +0000 (Fri, 27 Nov 2009) $, $Author: EckhardSutorius $
//-----------------------------------------------------------------------------
#ifndef TABLEDATA_H
#define TABLEDATA_H

#include <cstdlib>
#include <map>
#include <sstream>
#include <string>
#include <typeinfo>

#include "DataTypes.h"
#include "FitsFile.h"
#include "MyException.h"
#include "SchemaException.h"
#include "StringOps.h"
#include "Logger.h"
//-----------------------------------------------------------------------------
// Because we are using templates, we need these functions to make
// sure that the compiler can deal with the different combinations

extern inline void convertType(const Metadata& in, Numeric& out)
{
  // cstdlib's strtod() is much faster than stringstreams and this function
  // is the something of a bottleneck in the code at the moment
  out = std::strtod(in.c_str(), 0);
}
//-----------------------------------------------------------------------------
extern inline void convertType(const Metadata& in, Metadata& out)
{
  // @@TODO: If not used much tie in with int->metadata, and numeric->metadata
  // in a template
  out = in;
}
//-----------------------------------------------------------------------------
extern inline void convertType(const Numeric& in, Numeric& out)
{
  // @@TODO: Try to deprecate this function
  out = in;
}
//-----------------------------------------------------------------------------
extern inline void convertType(const Numeric& in, Metadata& out)
{
  // @@TODO: speed test!
  out = StringOps::NumToString(in);
}
//-----------------------------------------------------------------------------
extern inline void convertType(int in, Metadata& out)
{
  // @@TODO: speed test!
  out = StringOps::NumToString(in);
}
//-----------------------------------------------------------------------------
template<typename DataType>
class TableData
{
public:
  TableData(unsigned aNumCols, unsigned aNumRows)
    : mNumCols(aNumCols),
      mNumRows(aNumRows),
      mNumExts(0),
      mBufferAry(0),
      mDefinedAry(0)
  {
    // Size up arrays
    mBufferAry  = new DataType*[mNumCols];
    mDefinedAry = new bool*[mNumCols];
    for (unsigned col = 0; col < mNumCols; ++col)
    {
      mBufferAry[col]  = new DataType[mNumRows];
      mDefinedAry[col] = new bool[mNumRows];

      // Initially all entries are not defined
      for (unsigned row = 0; row < mNumRows; ++row)
      {
        mDefinedAry[col][row] = false;
      }
    }
  }
  //---------------------------------------------------------------------------
  ~TableData()
  {
    for (unsigned col = 0; col < mNumCols; ++col)
    {
      delete[] mBufferAry[col];
      delete[] mDefinedAry[col];
    }
    delete[] mBufferAry;
    delete[] mDefinedAry;
  }
  //---------------------------------------------------------------------------
  // Query dimensions of data table

  unsigned qNumRows() const { return mNumRows; }

  unsigned qNumCols() const { return mNumCols; }

  unsigned qNumExts() const { return mNumExts; }
  //---------------------------------------------------------------------------
  template <typename ADataType>
  void assign(unsigned aCol, unsigned aRow, ADataType v)
  {
    DataType useVal;
    convertType(v, useVal);
    writeToBuffer(aCol, aRow, useVal);
  }
  //---------------------------------------------------------------------------
  const DataType& at(unsigned aCol, unsigned aRow) const
  {
    return readBuffer(aCol, aRow);
  }
  //---------------------------------------------------------------------------
  template <typename ADataType>
  void value(unsigned aCol, unsigned aRow, ADataType& aValue) const
  {
    convertType(readBuffer(aCol, aRow), aValue);
  }
  //---------------------------------------------------------------------------
  bool isDefined(unsigned aCol, unsigned aRow) const
  {
    return readDefined(aCol, aRow);
  }
  //---------------------------------------------------------------------------
  void setundef(unsigned aCol, unsigned aRow)
  {
    writeToDefined(aCol, aRow, false);
  }
  //---------------------------------------------------------------------------
  void setNumExts(unsigned aNum)
  {
    writeToNumExts(aNum);
  }
  //---------------------------------------------------------------------------
  int getFirstDefinedRow(unsigned aCol)
  {
    unsigned row = 0;
    while (row < mNumRows && !isDefined(aCol, row))
    {
      ++row;
    }
    if (row == mNumRows)
    {
      return -1;
    }
    return row;
  }
  //---------------------------------------------------------------------------
  void loadFitsColumn(FitsFile& ff, const std::string &fitsColName,
                      unsigned aCol, unsigned firstRow)
  {
    ff.readColumn(fitsColName, &mBufferAry[aCol][firstRow]);
    for (unsigned aRow = firstRow;
                  aRow < firstRow + ff.getNumRows();
                  ++aRow)
    {
      writeToDefined(aCol, aRow, true);
    }
  }
  //---------------------------------------------------------------------------
  bool testRange(unsigned aCol,
                 unsigned aRow,
                 StringMap aRange)
  {
    unsigned noRng = aRange.size();
    Numeric useData;
    convertType(readBuffer(aCol, aRow), useData);
    if (noRng != 2)
    {
      std::string mess = "Range tag should contain exactly 2 values, but";
      mess += "contains " + StringOps::NumToString(noRng) + " values";
      throw SchemaException(mess);
      return false;
    }
    else
    {
      if (aRange[0] == "None" && aRange[1] != "None") // Max only
      {
        Numeric useVal[noRng];
        convertType(aRange[1], useVal[1]);
        return (useData <= useVal[1]);
      }
      else if (aRange[0] != "None" && aRange[1] == "None") // Min only
      {
        Numeric useVal[noRng];
        convertType(aRange[0], useVal[0]);
        return (useData >= useVal[0]);
      }
      else if (aRange[0] != "None" && aRange[1] != "None") // Both values
      {
        Numeric useVal[noRng];
        for (unsigned n = 0; n < noRng; n++)
        {
          convertType(aRange[n], useVal[n]);
        }
        return (useData >= useVal[0] && useData <= useVal[1]);
      }
      else
      {
        return true;
      }
    }
  } // testRange
  //---------------------------------------------------------------------------
  template <typename ADataType>
  bool testDiscrValues(unsigned aCol,
                       unsigned aRow,
                       std::map<int, ADataType> aValues)
  {
    std::string useData;
    convertType(readBuffer(aCol, aRow), useData);
    unsigned noVals = aValues.size();
    std::string useVal[noVals];
    bool testVal = false;
    for (unsigned n = 0; n < noVals; ++n)
    {
      convertType(aValues[n], useVal[n]);
      testVal = testVal || (useData==useVal[n]);
    }
    return testVal;
  }
  //---------------------------------------------------------------------------

private:
  unsigned mNumCols;
  unsigned mNumRows;
  unsigned mNumExts;
  DataType **mBufferAry;

  bool **mDefinedAry;

  //---------------------------------------------------------------------------
  void checkIsInRange(unsigned aCol, unsigned aRow) const
  {
    if (aCol >= mNumCols || aRow >= mNumRows)
    {
      std::stringstream errMsg;
      errMsg << "Error!: TableData: Cannot access data at "
             << aCol << ":" << aRow;
      throw MyException(errMsg.str());
    }
  }
  //---------------------------------------------------------------------------
  void writeToBuffer(unsigned aCol, unsigned aRow, DataType aValue)
  {
    checkIsInRange(aCol, aRow);
    mBufferAry[aCol][aRow] = aValue;
    mDefinedAry[aCol][aRow] = true;
  }
  //---------------------------------------------------------------------------
  void writeToDefined(unsigned aCol, unsigned aRow, bool aState)
  {
    checkIsInRange(aCol, aRow);
    mDefinedAry[aCol][aRow] = aState;
  }
  //---------------------------------------------------------------------------
  void writeToNumExts(unsigned aNum)
  {
    mNumExts = aNum;
  }
  //---------------------------------------------------------------------------
  const DataType& readBuffer(unsigned aCol, unsigned aRow) const
  {
    checkIsInRange(aCol, aRow);
    return mBufferAry[aCol][aRow];
  }
  //---------------------------------------------------------------------------
  bool readDefined(unsigned aCol, unsigned aRow) const
  {
    checkIsInRange(aCol, aRow);
    return mDefinedAry[aCol][aRow];
  }
};
//-----------------------------------------------------------------------------
#endif
//-----------------------------------------------------------------------------
// Change log:
//
// 28-Jan-2004,  IAB: Original version.
// 16-Nov-2005,  RSC: * Tidied up std namespace
//                    * Introduced more template functions to reduce code
//                    replication
// 21-Nov-2005,  RSC: * Moved SchemaException from TableInfo.h into its own
//                    file * Moved type definitions from TableData.hxx into new
//                    file DataTypes.h
// 13-Mar-2006,  RSC: * New function getFirstDefinedRow()
//                    * General tidy up
//  7-Apr-2008, ETWS: Upgraded to use new detection table layout.

---