---

CdbBdbLoadList.cc

Go to the documentation of this file.

// File and Version Information:
//      $Id: CdbBdbLoadList.cc,v 1.10 2004/08/17 23:51:29 avtelnov Exp $

/// This is the implementation file for the CdbBdbLoadList class
/**
  * @see CdbBdbLoadList
  */

#include "BaBar/BaBar.hh"

#include "CdbBdb/CdbBdbLoadList.hh"
#include "CdbBdb/CdbBdbObjectFactory.hh"

#include "CdbBase/Cdb.hh"
#include "CdbBase/CdbPathName.hh"
#include "CdbBase/CdbCondition.hh"

#include "BbrStdUtils/Tokenize.hh"
#include "BbrStdUtils/String.hh"
using namespace babar::String;

#include "ErrLogger/ErrLog.hh"

#include <fstream>

#include <string>
#include <vector>
#include <algorithm>
using std::endl;
using std::fstream;
using std::ifstream;

namespace {

    ////////////////////////////
    // Class: MyObjectFactory //
    ////////////////////////////

    class MyObjectFactory : public CdbBdbObjectFactory {
    public:

        MyObjectFactory( CdbBdbCreateCondObject theObjectCreatorFunction,
                         const std::string&     theObjectSource ) :
            _objectCreatorFunction(theObjectCreatorFunction),
            _objectSource(theObjectSource)
        { }

        virtual CdbStatus doCreate( BdbHandle(BdbObject)& theProduct,
                                    const BdbRefAny&      theHint );

    private:

        CdbBdbCreateCondObject _objectCreatorFunction;
        std::string            _objectSource;
    };

    CdbStatus
    MyObjectFactory::doCreate( BdbHandle(BdbObject)& theProduct,
                               const BdbRefAny&      theHint )
    {
        BdbRef(BdbObject) oRef;
        if( _objectCreatorFunction( _objectSource.c_str( ),
                                    const_cast<BdbRefAny&>(theHint),
                                    oRef )) {
            theProduct = oRef;
            return CdbStatus::Success;
        }
        return CdbStatus::Error;
    }

    ////////////////////////////
    // Class: MyObjectFactory //
    ////////////////////////////

    class StorePoint {
    public:

        StorePoint( const char*    theObjectSource = 0,
                    const BdbTime& theBeginTime    = BdbTime::minusInfinity ) :
            str(theObjectSource),
            begin(theBeginTime)
        { }

        StorePoint( const StorePoint& thePoint ) :
            str  (thePoint.str),
            begin(thePoint.begin)
        { }

        StorePoint& operator=( const StorePoint& thePoint )
        {
            str   = thePoint.str;
            begin = thePoint.begin;
            return *this;
        }

        std::string str;
        BdbTime     begin;
    };
};

///////////////////////////
// Class: CdbBdbLoadList //
///////////////////////////

CdbBdbLoadList::CdbBdbLoadList( const char*            sysname,
                                const char*            containername,
                                CdbBdbCreateCondObject function ) :
    _sysname(sysname),
    _contname(containername),
    _createfunction(function)
{ }

CdbBdbLoadList::~CdbBdbLoadList()
{ }

BdbStatus
CdbBdbLoadList::storeObjects( const char* filename )
{
  // pre-define the status as success

    BdbStatus status = BdbcSuccess;

  // create input stream from the file

    ifstream datafile( filename );
    if( datafile.good( )) {

      // create a list to store descriptions of objects to be created

        std::vector<StorePoint> objects;
        {
          // default time zone = utc

            std::string zonename( "UTC" );

          // loop over the lines in the file

            std::string fline;

            getline( datafile, fline );

            while( ! datafile.eof( )) {

              // skip comments and blank lines

                if(( ! fline.empty( )) && fline.find( "#", 0, 1 ) == std::string::npos ) {

                  // tokenize the string

                    Tokenize linetokens( fline );

                  // first 2 must be date and time

                    std::string date = linetokens( );
                    std::string time = linetokens( );

                  // The following commented line was introduced in v1.7. Aborting with time.empty() makes the use 
                  // of time "+Infinity" impossible. I am fixing this bug now. -- Sasha Telnov, 2004/08/16
                  //  if( date.empty( ) || time.empty( ))
                    if( date.empty() || (time.empty() && date != "+Infinity" && date != "-Infinity" ) )
                        ErrMsg(fatal) << "badly formatted contents of the file to be loaded \"" << filename << "\"" << endl
                                      << "at line \"" << fline << "\"." << endmsg;

                  // check for a zone specification

                    if ( 0 == compare_nocase( date, "Zone" )) {
                        zonename = time;
                    } else {

                      // otherwise, interpret it as a time

                        BdbTime bdbtime(0);
                        {
                            BdbTime::Zone zone = BdbTime::UTC;
                            if( 0 == compare_nocase( zonename, "UTC" ));    // already have it
                            else if( 0 == compare_nocase( zonename, "Local" )) zone = BdbTime::Local;
                            else {
                                ErrMsg(error) << "unrecognized timezone \"" << zonename << "\"" << endl
                                              << "when reading file \"" << filename << "\"" << endl
                                              << "at line \"" << fline << "\"." << endmsg;
                                return BdbcError;
                            }
                            if( ! BdbTime::parseTime( date, time, zone, bdbtime )) {

                                ErrMsg(error) << "failed to translate data and time \"" << date << "\" \"" << time << "\"" << endl
                                              << "when reading file \"" << filename << "\"" << endl
                                              << "at line \"" << fline << "\"." << endmsg;
                                return BdbcError;
                            }
                        }

                      // concatonate the remaining tokens as a single string

                        std::string token;
                        std::string objstring;

                        while( ! ( token = linetokens( )).empty( )) {

                            if( ! objstring.empty( )) objstring.append( " " );   // put back the token
                            objstring.append( token );
                        }

                        if( ! objstring.empty( )) {

                          // add an element to the vector

                            objects.push_back( StorePoint( objstring.c_str( ),
                                                           bdbtime ));

                        } else {

                          // null string: insert a placeholder in the list

                            objects.push_back( StorePoint( "",
                                                           bdbtime ));
                        }
                    }
                }

              // read the next line

                getline( datafile, fline );
            }
        }

      // Invoke the actual objects creation for each element of the vector
      // if the input file has enough elements to load.

        std::vector<StorePoint>::size_type num = objects.size( );

        if( num < 2 ) {
            ErrMsg(error) << "insuffient contents of the objects list file \"" << filename << "\""
                          << " : Conditions load aborted " << endmsg;
            status = BdbcError;
        } else {

            startTransaction( BdbcUpdate );
            {
                std::string cName = std::string( CdbPathName::separator( )) +
                                    _sysname +
                                    std::string( CdbPathName::separator( )) +
                                    _contname;

                CdbConditionPtr cPtr;
                if( CdbStatus::Success != CdbCondition::instance( cPtr,
                                                                  cName.c_str( ))) {
                    ErrMsg(error) << "failed to locate condition \"" << cName << "\""
                                  << " in the database : Conditions load aborted " << endmsg;
                    status = BdbcError;
                } else {

                    for( std::vector<StorePoint>::size_type i = 0; i < num - 1; ++i ) {

                        MyObjectFactory oFactory( _createfunction, objects[i].str );

                        if( CdbStatus::Success != cPtr->storeObject( oFactory,
                                                                     objects[i].begin,
                                                                     objects[i+1].begin )) {

                            ErrMsg(fatal) << "error creating and storing object(s) from file \"" << filename << "\""
                                          << " : Conditions load aborted " << endmsg;
                        }
                    }
                }
            }
            endTransaction( );
        }

    } else {
        ErrMsg(error) << "can't open object list file \"" << filename << "\"" << endmsg;
        status = BdbcError;
    }
    return status;
}

---