FitsNTuple.cxx

Go to the documentation of this file.

#include "FitsFile.h"
#include "FitsNTuple.h"

#include "axes/Range.h"
#include "datasrcs/DataSourceException.h"

#include <cassert>

using std::string;
using std::vector;

FitsNTuple::
FitsNTuple ( FitsFile * file )
  : DataSource ( false ),
    m_file ( file )
{
  m_hdu_num = m_file -> getHDUNumber ();
  initColumns ();
}

FitsNTuple::
FitsNTuple ( )
  : DataSource ( false ),
    m_file ( 0 )
{
}

FitsNTuple::~FitsNTuple()
{
}

void
FitsNTuple::
copy ( const DataSource  & )
{
  assert ( false );
}

const FitsFile *
FitsNTuple::
getFile () const
{
  return m_file;
}

void 
FitsNTuple::
initColumns ( )
{
  vector < string > labels;
  vector < double > values;
  m_file -> fillColumnNames ( labels );
  unsigned int size = labels.size ();

  for ( unsigned int i = 0; i < size; i++ ) {
    const string & label = labels [i];
    addColumn ( label, values );
  }
}

void
FitsNTuple::
notifyObservers ( ) const
{
  Observable::notifyObservers ();
}

unsigned int
FitsNTuple::
rows() const
{
  return m_file -> getNumberOfRows ();
}

int
FitsNTuple::
fillDataCache ( unsigned int column )
{
  unsigned int size = rows ();
  vector < double > * cache = new vector < double > ( size );
  int status = m_file -> fillDoubleVectorFromColumn ( *cache, column );

  m_data [ column ] = cache;

  return status;
}

void
FitsNTuple::
clear ()
{
  for ( unsigned int i = 0; i < m_data.size (); i++ ) {
    if ( m_data[i] != 0 ) {
      delete m_data[i];
    }
    m_data[i] = 0;
  }
//   m_rows = 0;
}

void
FitsNTuple::
reserve ( unsigned int count )
{
  assert ( false );
}

bool
FitsNTuple::
empty () const
{
  return rows () == 0;
}

void
FitsNTuple::
addRow ( const std::vector < double > & row )
{
  assert ( false );
}

double
FitsNTuple::
operator [] (  std::vector < unsigned int > & indices ) const
{
  assert ( false );
  return 0.0;
}

double
FitsNTuple::
valueAt ( unsigned int row, unsigned int column ) const
{
  if ( m_data [ column ] == 0 ) {
    FitsNTuple * rtuple = const_cast < FitsNTuple * > ( this );
    rtuple -> fillDataCache ( column );
  }
  const vector < double > & cache = *m_data [ column ];

  return cache[row];
}

const std::vector < double > &
FitsNTuple::
getRow ( unsigned int row ) const
{
  unsigned int size = m_data.size();
  m_array.resize ( size );
  for ( unsigned int column = 0; column < size; column++ ) {
    m_array [ column ] = valueAt ( row, column );
  }

  return m_array;
}

bool
FitsNTuple::
fillRange ( unsigned int column, Range & range ) const
{
  bool isValid = false;
  if ( m_data [ column ] == 0 ) {
    FitsNTuple * rtuple = const_cast < FitsNTuple * > ( this );
    int status = rtuple -> fillDataCache ( column );
    if ( status == 0 ) isValid = true;
  }
  vector < double > & v = *m_data[column];

  range.setRange ( v.begin(), v.end() );

  return isValid;
}

int
FitsNTuple::
addColumn ( const std::string & label,
            const std::vector < double > & column )
{
  // Check if label already exists.
  int index = indexOf ( label );
  if ( index >= 0 ) {
    string what ( "FitsNTuple: Attempt to add a column whose label"
                  " is same as other column." );
    throw DataSourceException ( what );
  }

  unsigned int new_size = column.size ();

  // Check if column has right size.
  if ( m_data.empty () == false &&
       column.empty() == false ) {
    unsigned int old_size = rows ();

    if ( old_size != 0 && old_size != new_size ) {
      string what ( "FitsNTuple Attempt to add a column whose size"
                    " is not equal to other columns." );
      throw DataSourceException ( what );
    }
  }
  if ( column.empty () ) {
    m_data.push_back ( 0 );
  }
  else {
    vector < double > * vec = new vector < double > ( column );
    m_data.push_back ( vec );
  }
  addLabel ( label );

  return m_data.size() - 1;
}

void
FitsNTuple::
replaceColumn ( unsigned int index, const std::vector < double > & data )
{
  unsigned int size = columns ();
  if ( index >= size ) {
    const string what
      ( "FitsNTuple: Attempt to replace non-existant column." );
    throw DataSourceException ( what );
  }
  size = rows ();
  unsigned int new_size = data.size ();
  if ( size != 0 && size != new_size ) {
    const string what
      ( "FitsNTuple: Attempt to replace column with one whose "
        "size is not equal to other columns." );
      throw DataSourceException ( what );
  }
  
  m_data [ index ] -> resize ( new_size );
  std::copy ( data.begin(), data.end (), m_data [ index ] -> begin () );

  notifyObservers ();
}

void
FitsNTuple::
replaceColumn ( const std::string & label,
                const std::vector < double > & data )
{
  unsigned int index = indexOf ( label );
  replaceColumn ( index, data );
}

void
FitsNTuple::
setShape ( std::vector < unsigned int > & shape )
{
  assert ( false ); // not tested
  unsigned int size = 1;
  for ( unsigned int i = 0; i < shape.size(); i++ ) {
    size *= shape[i];
  }

  m_shape = shape;
}

const vector < unsigned int > &
FitsNTuple::
getShape () const
{
  assert ( false ); // not tested
  return m_shape;
}

unsigned int
FitsNTuple::getRank () const
{
  assert ( false ); // not tested

  return m_shape.size();
}

---