---

CdbProxyBaseTest.cc

Go to the documentation of this file.

// File and Version Information:
//      $Id: CdbProxyBaseTest.cc,v 1.8 2004/12/08 09:49:49 gapon Exp $
#include "BaBar/BaBar.hh"

/// This is a test application for the CdbBdbProxyBase class
/**
  * This application implements a simple proxy class deriving
  * from the CdbBdbProxyBase class.
  */
#include "CdbBdbWrapper/CdbBdbWrapper.hh"

#include "CdbBdb/CdbBdbProxyBase.hh"
#include "CdbBdb/CdbBdbProxyElement.hh"
#include "CdbBdb/CdbBdbEnvProxy.hh"

#include "BdbTime/BdbTime.hh"

#include "BdbCond/BdbConditions.hh"
#include "BdbCondTests/EmcFooClassP.hh"

#include "ProxyDict/IfdSimpleProxyDict.hh"
#include "ProxyDict/Ifd.hh"
#include "ProxyDict/IfdStrKey.hh"

#include "AbsEnv/AbsEnv.hh"
#include "GenEnv/GenEnv.hh"

#include <stdio.h>  // sscanf()

#include <string>
using std::cerr;
using std::cout;
using std::endl;

/// The transient product of our test proxy
/**
  * This class is meant to test the simple proxy. When it's
  * constructor is called a persistent reference onto the real
  * condition object is stored as adata member of the class.
  */
class SimpleProxyProduct {
private:

  /// Default constructor (NOT IMMPLEMENTED)

    SimpleProxyProduct( );

public:

  /// Normal constructor

    SimpleProxyProduct( const BdbRef(BdbObject)& theRef ) :
        ref(theRef)
    { }

public:

    BdbRef(BdbObject) ref;
};

/// The simple proxy class
/**
  * In order to test this class, the corresponding persistent condition
  * must exist in the database.
  */
class SimpleProxy : public CdbBdbProxyBase<SimpleProxyProduct> {

public:

    SimpleProxy( )
    {
        subscribeCondition( "/emc/EmcFooClassP" );
    }
static void doTest( const std::string& theRevisionName,
                    unsigned int       thePartitionId );

    virtual ~SimpleProxy( )
    { }

  /// Implement the user defined fault handler.
  /**
    * Remember, that the base class gurantees that the following method
    * is executed within the read mode transaction. Therefore we can get
    * updated persistent and build the transient product.
    *
    * We also should not warry about the lifetime of the transient product,
    * all of this will be handled by the caller.
    */
    virtual SimpleProxyProduct* redefinedFaultHandler( const std::vector<CdbBdbProxyElement>& listOfElements )
    {
        cout << "SimpleProxy::redefinedFaultHandler() - BEGIN" << endl
             << endl;

        cout << "    FAULT TIME: " << faultTime( ) << endl;

        CdbBdbProxyElement e;

        std::vector<CdbBdbProxyElement>::const_iterator itr;
        for( itr = listOfElements.begin( ); itr < listOfElements.end( ); ++itr ) {

            e = (*itr);

            cout << "    CONDITION NAME:       " << e.name( ) << endl
                 << "    CONDITION SHORT NAME: " << e.shortName( ) << endl
                 << "    VALIDITY INTERVAL:    " << e.validity( ) << endl
                 << "    OBJECT:               " << e.objectRef( ).sprint( ) << endl
                 << "    HAS BEEN UPDATED:     " << ( e.updated( ) ? "Yes" : "No" ) << endl
                 << endl;
        }
        cout << "SimpleProxy::redefinedFaultHandler() - END" << endl;

      // Construct the transient product and pass a persistent reference to it.
      // Looks a bit silly, but it's fine for the testing purposes.

        return new SimpleProxyProduct( e.objectRef( ));
    }
};

/// The simple proxy class using explicitly specified revision name and a partition
/**
  * In order to test this class, the corresponding persistent condition
  * must exist in the database.
  */
class SimpleProxyUsingRevision : public CdbBdbProxyBaseUsingRevision<SimpleProxyProduct> {

public:

    SimpleProxyUsingRevision( const std::string& theRevisionName,
                              unsigned int       thePartitionId ) :
        CdbBdbProxyBaseUsingRevision<SimpleProxyProduct>( theRevisionName,
                                                          thePartitionId )
    {
        subscribeCondition( "/emc/EmcFooClassP" );
    }
    virtual ~SimpleProxyUsingRevision( )
    { }

  /// Implement the user defined fault handler.
  /**
    * Remember, that the base class gurantees that the following method
    * is executed within the read mode transaction. Therefore we can get
    * updated persistent and build the transient product.
    *
    * We also should not warry about the lifetime of the transient product,
    * all of this will be handled by the caller.
    */
    virtual SimpleProxyProduct* redefinedFaultHandler( const std::vector<CdbBdbProxyElement>& listOfElements )
    {
        cout << "SimpleProxyUsingRevision::redefinedFaultHandler() - BEGIN" << endl
             << endl;

        cout << "    FAULT TIME: " << faultTime( ) << endl;

        CdbBdbProxyElement e;

        std::vector<CdbBdbProxyElement>::const_iterator itr;
        for( itr = listOfElements.begin( ); itr < listOfElements.end( ); ++itr ) {

            e = (*itr);

            cout << "    CONDITION NAME:       " << e.name( ) << endl
                 << "    CONDITION SHORT NAME: " << e.shortName( ) << endl
                 << "    VALIDITY INTERVAL:    " << e.validity( ) << endl
                 << "    OBJECT:               " << e.objectRef( ).sprint( ) << endl
                 << "    HAS BEEN UPDATED:     " << ( e.updated( ) ? "Yes" : "No" ) << endl
                 << endl;
        }
        cout << "SimpleProxy::redefinedFaultHandler() - END" << endl;

      // Construct the transient product and pass a persistent reference to it.
      // Looks a bit silly, but it's fine for the testing purposes.

        return new SimpleProxyProduct( e.objectRef( ));
    }
};

///////////
// Tests //
///////////

static void doTest( IfdDataProxyTemplate<SimpleProxyProduct>* theProxyPtr );

/////////////
// Helpers //
/////////////

static void usage( )
{
    cout << "Usage: simple" << endl
         << "       using_revision [ <revision_name> <partition_id>]" << endl;
}

////////////////////////////////////////
// Starting point for the application //
////////////////////////////////////////

int
main( int argc, char** argv )
{
  // Translate input parameters. The valid syntax is:
  //
  // simple
  // using_revision [ <revision_name> <partition_id>]

    if( argc <= 1 ) {
        usage( );
        return 0;
    }
    int numArgs = argc - 1;
    int nextArg = 1;

    std::string command = argv[nextArg++];
    numArgs = numArgs - 1;

    std::string  revisionName;
    unsigned int partitionId;

    if( "simple" == command ) {

      // No more parameters

        ;

    } else if( "using_revision" == command ) {

        if( numArgs < 2 ) {
            cerr << "error: illegal number of argments." << endl;
            usage( );
            return 1;
        }
        revisionName = argv[nextArg++];
        if( 1 != sscanf( argv[nextArg++], "%u", &partitionId )) {
            cerr << "error: failed to translate the partition identifier." << endl;
            usage( );
            return 1;
        }
        numArgs = numArgs - 2;
    }
    if( 0 != numArgs ) {
        cerr << "error: unexpected parameters found in the command line." << endl;
        usage( );
        return 1;
    }

  // Make sure the proper libraries are linked and factories
  // are instantiated.

    CdbBdbWrapper::forceLoad( );

  // The current implementation requires _external_ transaction management.

    BdbConditions::instance( )->startRead( );

    if     ( "simple"         == command ) doTest( new SimpleProxy( ));
    else if( "using_revision" == command ) doTest( new SimpleProxyUsingRevision( revisionName, partitionId ));
    else {
        assert( 0 );
    }

    BdbConditions::instance( )->commit( );
}

static void
doTest( IfdDataProxyTemplate<SimpleProxyProduct>* theProxyPtr )
{
    assert( 0 != theProxyPtr );

  // Simulate global environment

    gblEnv = new AbsEnv( );
    gblEnv->setGen( new GenEnv( ));

    BdbTime currentTime( BdbTime::now( ));
    EidCondKeyTriplet primaryTriplet   ( 0, 0, currentTime );
    EidCondKeyTriplet backgroundTriplet( 0, 0, currentTime );

    gblEnv->getGen( )->setConditionsKeys( &currentTime,
                                                      &primaryTriplet, 
                                                      &backgroundTriplet );

    gblPEnv = new IfdSimpleProxyDict;

  // Register our simple proxy

    bool result = Ifd<SimpleProxyProduct>::put( gblPEnv,
                                                theProxyPtr,
                                                IfdStrKey( "EmcFooClassP" ));
    if( !result ) cerr << "failed to put the proxy into the dictionary." << endl;

  // Try to use the proxy

    const SimpleProxyProduct* t;
    
    for( int i = 0; i < 5; ++i ) {
        t = Ifd<SimpleProxyProduct>::get( gblPEnv,
                                          IfdStrKey( "EmcFooClassP" ));
        if( 0 == t ) {
            cout << "Ifd<T>::get() failed and returned 0 pointer onto a transient object." << endl
                 << endl;
        } else {
            cout << "Ifd<T>::get() succeded. The OID: " << t->ref.sprint( ) << endl
                 << endl;
        }

      // Change the time at the global environment. This will invalidate the proxy

        currentTime       = BdbTime( BdbTime::now( ));
        primaryTriplet    = EidCondKeyTriplet( 0, 0, currentTime );
        backgroundTriplet = EidCondKeyTriplet( 0, 0, currentTime );

        gblEnv->getGen( )->setConditionsKeys( &currentTime,
                                                      &primaryTriplet, 
                                                      &backgroundTriplet );
    }

  // Just do the compilation test for the "Environment" proxy

    CdbBdbEnvProxy<EmcFooClass,EmcFooClassP> envProxyTest( "emc", "EmcFooClassP" );
}

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

---