---

CdbNTupleBase.cc

Go to the documentation of this file.

// File and Version Information:
//      $Id: CdbNTupleBase.cc,v 1.4 2004/08/06 05:54:41 bartoldu Exp $

/// The implementation of the CdbNTupleBase class.
/**
  * @see CdbNTupleBase
  */

#include "BaBar/BaBar.hh"

#include "CdbTable/CdbNTupleBase.hh"

#include <iostream>
#include <assert.h>
#include <stdio.h>
using std::cout;
using std::endl;

namespace {

    std::string default_name_for_column( unsigned int theNumber )
    {
        char str[20];
        sprintf( str, "%u", theNumber );
        return std::string( "#" ) + std::string( str );
    }

  // This function wil always resize the original size of the passed array
  // to specified length.

    void init_default_column_names( std::vector<std::string>& theColumns,
                                    unsigned int              theNumberOfColumns )
    {
        theColumns.resize( theNumberOfColumns );
        for( unsigned int i = 0; i < theNumberOfColumns; ++i ) {
            theColumns[i] = default_name_for_column( i );
        }
    }
};

CdbNTupleBase::~CdbNTupleBase( )
{ }

CdbNTupleBase::CdbNTupleBase( unsigned int       theNumberOfColumns,
                              const std::string& theName,
                              const std::string& theDescription ) :
    _ncol(theNumberOfColumns),
    _name(theName),
    _description(theDescription)
{
    ::init_default_column_names( _columns,
                                 _ncol );
}

CdbNTupleBase::CdbNTupleBase( unsigned int                    theNumberOfColumns,
                              const std::vector<std::string>& theCollumnNames,
                              const std::string&              theName,
                              const std::string&              theDescription ) :
    _ncol(theNumberOfColumns),
    _name(theName),
    _description(theDescription)
{
    const char* fatalStr = "CdbNTupleBase::CdbNTupleBase() -- FATAL ERROR IN THE CONSTRUCTOR.";

  // Initialize column names with defaults

    ::init_default_column_names( _columns,
                                 _ncol );

  // Verify a vector with column names passed as a parameter to see if
  // these names satisfy the naming rules described at the contract of the current
  // class.
  //
  // @see CdbNTupleBase::CdbNTupleBase

    unsigned int num = theCollumnNames.size( );

    if( _ncol < num ) num = _ncol;  // Ignore the rest of the vector if it's
                                    // longer than the number of actual columns.

    for( unsigned int i = 0; i < num; ++i ) {

      // Check if a "system" style name is being attempted to use. Note, that
      // "system" names begin with the '#' symbols. The use of these names is
      // reserved to the implementations of the tuples. The only exception
      // allowed by the naming rules is when default system names are specified
      // in the right positions.

        if( theCollumnNames[i][0] == '#' ) {

            if( theCollumnNames[i] == _columns[i] ) continue;

            cout << fatalStr << endl
                 << "    An attemp to use a reserved name of the column \"" << theCollumnNames[i].c_str( ) << " has been detected" << endl
                 << "    while constructing an object of the current class. See the contract of the class" << endl
                 << "    for further details on how the columns should be named." << endl
                 << endl
                 << "    Here is a list of all names passed to the constructor:" << endl
                 << endl;

            for( unsigned int j = 0; j < num; ++j ) cout << "        " << j << " : \"" << theCollumnNames[j].c_str( ) << "\"" << endl;

            assert( 0 );
            ::exit( 1 );
        }

      // Check if our caller is not trying to duplicate the names which are
      // already stored at the begining.

        for( unsigned int j = 0; j < _ncol; ++j ) {
            if( theCollumnNames[i] == _columns[j] ) {

                cout << fatalStr << endl
                     << "    A vector containing duplicate column names passed to the current constructor." << endl
                     << "    See the contract of the class for further details on how the columns should be named." << endl;

                assert( 0 );
                ::exit( 1 );
            }
        }
        _columns[i] = theCollumnNames[i];
    }
}

CdbNTupleBase::CdbNTupleBase( const CdbNTupleBase& theOther ) :
    _ncol       (theOther._ncol),
    _name       (theOther._name),
    _description(theOther._description),
    _columns    (theOther._columns)
{ }

CdbNTupleBase&
CdbNTupleBase::operator=( const CdbNTupleBase& theOther )
{
    if( &theOther != this ) {
        _ncol        = theOther._ncol;
        _name        = theOther._name;
        _description = theOther._description;
        _columns     = theOther._columns;
    }
    return *this;
}

unsigned int
CdbNTupleBase::columns( ) const
{
    return _ncol;
};

std::string
CdbNTupleBase::name( ) const
{
    return _name;
}

void
CdbNTupleBase::set_name( const std::string& theName )
{
    _name = theName;
}

std::string
CdbNTupleBase::description( ) const
{
    return _description;
}

void
CdbNTupleBase::set_description( const std::string& theDescription )
{
    _description = theDescription;
}

void
CdbNTupleBase::column_names( std::vector<std::string>& theVectorOfNames ) const
{
    theVectorOfNames = _columns;
}


CdbStatus
CdbNTupleBase::column_name( unsigned int theNumber,
                            std::string& theName ) const
{
    if( theNumber >= _ncol ) return CdbStatus::NotFound;
    theName = _columns[theNumber];
    return CdbStatus::Success;
}

CdbStatus
CdbNTupleBase::column_number( const std::string& theName,
                              unsigned int&      theNumber ) const
{
    for( unsigned int i = 0; i < _ncol; ++i ) {
        if( theName == _columns[theNumber] ) {
            theNumber = i;
            return CdbStatus::Success;
        }
    }
    return CdbStatus::NotFound;
}

CdbStatus
CdbNTupleBase::set_column_name( unsigned int       theNumber,
                                const std::string& theName )
{
    if( theNumber >= _ncol ) return CdbStatus::NotFound;
     _columns[theNumber] = theName;
    return CdbStatus::Success;
}

bool
CdbNTupleBase::is_system_name( const std::string& theName )
{
    return '#' == theName.c_str( )[0];
}

std::string
CdbNTupleBase::default_column_name( unsigned int theNumber )
{
    return ::default_name_for_column( theNumber );
}

/////////////////
// End Of File //
/////////////////

---