ListTuple.cxx

Go to the documentation of this file.

#include "ListTuple.h"

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

using namespace boost::python;

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

namespace
{
  unsigned int getSize ( const boost::python::list & sequence )
  {
    object obj = sequence.attr ( "__len__" ) ();

    return extract < unsigned int > ( obj );
  }
}

ListTuple::ListTuple ()
  : DataSource ()
{
}

ListTuple::~ListTuple()
{
}

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

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

unsigned int
ListTuple::
rows() const
{
  unsigned int size = 0;
  if ( m_data.empty () == false ) {
    const boost::python::list & seq = m_data[0];

    size = getSize ( seq );
  }

  return size;
}

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

double
ListTuple::
valueAt( unsigned int row, unsigned int column ) const
{
  assert ( column < m_data.size () );

  const boost::python::list & seq = m_data[column];

  unsigned int size = getSize ( seq );

  assert ( row < size );

  object result = seq[row];
  double value = extract < double > ( result );

  return value;
}

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

  return m_row;
}

bool
ListTuple::
isAcceptable ( const  boost::python::list & array )
{
  bool yes = true;
  unsigned int size = getSize ( array );
  for ( unsigned int i = 0; i < size; i++ ) {
    object obj = array[i];
    extract < double > check ( obj );
    if ( check.check() == false ) {
      yes = false;
      break;
    }
  }
  return yes;
}

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

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

    if ( old_size != 0 && old_size != new_size ) {
      string what ( "ListTuple Attempt to add a column whose size"
                    " is not equal to other columns." );
      throw DataSourceException ( what );
    }
  }
  if ( isAcceptable ( array ) == false ) {
    string what ( "ListTuple: Attempt to add a column with one or more"
                  " elements not convertable to float" );
    throw DataSourceException ( what );
  }

  m_data.push_back ( array );
  addLabel ( label );

  return m_data.size() - 1;
}

void
ListTuple::
replaceColumn ( unsigned int col, 
                boost::python::list array )
{
  unsigned int size = columns ();
  if ( col >= size ) {
    const string what ( "NunArrayTuple: column doesn't exist" );
    throw DataSourceException ( what );
  }

  const boost::python::list & old_array = m_data[col];
  int old_size = getSize ( old_array );
  int new_size = getSize ( array );

  if ( old_size != 0 && old_size != new_size ) {
    const string what ( "ListTuple: Attempt to replace column with one "
                        "whose size is not equal to other columns." );
    throw DataSourceException ( what );
  }
  m_data[col] = array;

  notifyObservers ();
}

void
ListTuple::
replaceColumn ( const std::string & column,
                boost::python::list array )
{
  unsigned int index = indexOf ( column );

  replaceColumn ( index, array );
}

void
ListTuple::
setShape ( std::vector < unsigned int > & shape )
{
  unsigned int size = 1;
  for ( unsigned int i = 0; i < shape.size(); i++ ) {
    size *= shape[i];
  }

  m_shape = shape;
}

const vector < unsigned int > &
ListTuple::
getShape () const
{
  return m_shape;
}

unsigned int
ListTuple::getRank () const
{
  return m_shape.size();
}

void
ListTuple::
clear ()
{
  assert ( false );
}

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

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

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

---