DataSourceController.cxx

Go to the documentation of this file.

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

// for truncation warning in debug mode
#ifdef _MSC_VER
#include "msdevstudio/MSconfig.h"
#endif

#include "DataSourceController.h"

#include "DataSource.h"
#include "DataSourceException.h"

#include <algorithm>
#include <fstream>

#ifdef SSTREAM_DEFECT
#include <strstream>
using std::ostrstream;
#else
#include <sstream>
using std::ostringstream;
#endif

#include <utility>
#include <cassert>

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

DataSourceController * DataSourceController::s_instance = 0;

DataSourceController::DataSourceController ( )
  : m_base_name ( "in-memory" ),
    m_suffix ( 0 )
{
}

DataSourceController::DataSourceController ( const DataSourceController & )
{
  assert ( false );
}

DataSourceController * DataSourceController::instance ( )
{
  if ( s_instance == 0 ) {
    s_instance = new DataSourceController ( );
  }
  return s_instance;
}

void
DataSourceController::
registerDataSourceFile ( DataSource * ds )
{
  m_ds_files.push_back ( ds );
}

DataSource * 
DataSourceController::
findDataSource ( const std::string & name ) const 
  throw ( DataSourceException )
{
  DataSource * source = getDataSource ( name );

  if ( source == 0 ) {
    string what ( "DataSourceController: No NTuple with name `" );
    what += name;
    what += "' has been registered";
    throw DataSourceException ( what );
  }

  return source;
}

int
DataSourceController::
indexOfDataSource ( const std::string & name ) const
{
  int index = -1;
  DataSourceList_t::size_type size = m_tuples.size ();
  DataSourceList_t::size_type i = 0;

  for ( ; i < size; i++ ) {
    DataSource * ds = m_tuples [ i ];
    const string & ds_name = ds -> getName ();
    if ( ds_name == name ) {
      index = i;
      break;
    }
  }
  return index;
}

DataSource * 
DataSourceController::
getDataSource ( const std::string & name ) const
{
  DataSource * source = 0;

  DataSourceList_t::size_type size = m_tuples.size (), i = 0;
  for ( ; i < size; i++ ) {
    DataSource * ds = m_tuples [ i ];
    const string & ds_name = ds -> getName ();
    if ( ds_name == name ) {
      source = ds;
      break;
    }
  }

  return source;
}

void
DataSourceController::
changeName ( const std::string & old_name, 
             const std::string & new_name )
{
  DataSource * ntuple = getDataSource ( old_name );
  if ( ntuple != 0 ) {
    ntuple -> setName ( new_name );
  }
}

const vector < DataSource * > &
DataSourceController::
getDataSources ( bool all ) const
{
  return m_tuples;
}

const vector < string > & DataSourceController::getNTupleNames () const
{
  m_names.clear ();

  DataSourceList_t::const_iterator i = m_tuples.begin ();
  while ( i != m_tuples.end() ) {
    const DataSource * source = *i++;
    const string & name = source -> getName ();
    m_names.push_back ( name );
  }

  return m_names;
}

string
DataSourceController::
registerNTuple ( DataSource * ds )
{

  string text = ds ->getName ();
  if ( text.empty () ) {
#ifdef SSTREAM_DEFECT
    ostrstream strm_text;
#else
    ostringstream strm_text;
#endif
    strm_text << "<" << m_base_name << ++m_suffix << ">" << std::ends;
    text = strm_text.str();
  }

  ds->setName ( text );
  registerNTuple ( text, ds );

  return text;
}

void
DataSourceController::
registerNTuple ( const std::string & key, DataSource * ntuple )
{
  DataSource * source = getDataSource ( key );
  if ( source != 0 ) {
    string what ( "DataSourceController: NTuple with name:\n");
    what += key;
    what += "\nhas already been registered";
    throw DataSourceException ( what );
  }
  ntuple -> addObserver ( this );

  m_tuples.push_back ( ntuple );
}

void
DataSourceController::
unregisterNTuple ( const DataSource * ntuple )
{
  DataSourceList_t::iterator i 
    = std::find ( m_tuples.begin(), m_tuples.end(), ntuple );
  if ( i != m_tuples.end () ) {
    m_tuples.erase ( i );
  }
}

void
DataSourceController::
update ( const Observable * obs )
{
}

void
DataSourceController::
willDelete ( const Observable * observee )
{
  const DataSource * ntuple 
    = dynamic_cast < const DataSource * > ( observee );
  if ( ntuple == 0 ) return; // not NTuple

  unregisterNTuple ( ntuple );
}

bool 
DataSourceController::
isSaved ( const std::string & name )
{
  string::size_type i = name.find ( m_base_name );
  bool not_saved = i != string::npos;

  return ! not_saved;
}

---