Bdb packages | Design docs | Source docs | Guidelines | Recent releases
	Search | Site Map .

                 

---

/BdbScribeTest/tstManyToOne.cc

Go to the documentation of this file.

#if !defined(TSTMANYTOONE_CC)
#define TSTMANYTOONE_CC
//--------------------------------------------------------------------------
// File and Version Information:
//      $Id: tstManyToOne.cc,v 1.5 2001/04/23 23:54:22 patton Exp $
//
// Description:
//      Class TstManyToOne
//
// Environment:
//      Software developed for the BaBar Detector at the SLAC B-Factory.
//
// Author List:
//      Simon Patton            Originator
//
// Copyright Information:
//      Copyright (C) 1999      LBNL
//
//------------------------------------------------------------------------

//-------------
// C Headers --
//-------------
extern "C" {
           }

//---------------
// C++ Headers --
//---------------
#include <iostream.h>
#include <stdlib.h>
#include <stdio.h>

//----------------
// BaBar Header --
//----------------
#include "BaBar/BaBar.hh"
#include "BdbUtil/Bdb.hh"

//-------------------------------
// Collaborating Class Headers --
//-------------------------------
#include "BdbScribeTest/BdbScribeChkCompositeP_001.hh"
#include "BdbScribeTest/BdbScribeChkCompositeP_000.hh"
#include "BdbScribeTest/BdbScribeChkClass.hh"
#include "BdbScribeTest/BdbScribeChkPlaceMgr.hh"
#include "BdbScribes/BdbCompositeScribe.hh"
#include "BdbScribes/BdbConversionManager.hh"
#include "BdbEvent/BdbEventT.hh"
#include "BdbEvent/BdbEvent.hh"
#include "BdbTrees/BdbHeaderKeysMgr.hh"
#include "ProxyDict/IfdStrKey.hh"
#include "AbsEvent/getTmpAList.hh"
#include "AbsEvent/AbsEvent.hh"
#include "ErrLogger/ErrLog.hh"

//------------------------------------
// Collaborating Class Declarations --
//------------------------------------

//-----------------------------------------------------------------------
// Local Macros, Typedefs, Structures, Unions and Forward Declarations --
//-----------------------------------------------------------------------

//
// Trivial FD operations
//

ooHandle( ooFDObj ) fdH ;
ooHandle( ooDBObj ) dbH ;

d_Boolean fd_begin()
{
   const char* kDbName( "BdbScribeTest" ) ;

   if ( oocError == fdH.open( 0 ,
                              oocUpdate ,
                              oocFalse ) ) {
      return ( false ) ;
   }

   if ( ! dbH.exist( fdH ,
                     kDbName ) ) {
      dbH = new(fdH)ooDBObj( kDbName ) ;
   }

   return( !false ) ;
}

int main()
{
   ooInit() ;
   ooCheckVTablePointer() ;

   ooTrans gTransaction ;

   // Start a federation transaction
   gTransaction.start() ;

   if ( ! fd_begin() ) {
      ErrMsg( fatal ) << "Failed to open Federated Database."
                      << endmsg ;
      exit( -1 ) ;
   }

   // Create transient and persistent events.
   AbsEvent* transEvent( new AbsEvent ) ;
   BdbHandle( BdbEvent ) persEvent ;
   persEvent = new ( dbH ) BdbEvent ;
//   BdbEventT eventT( persEvent ) ;

   BdbHandle( BdbHeaderKeysMgr ) keysManager ;
   keysManager = new( dbH )BdbHeaderKeysMgr() ;
   BdbEventT eventT( persEvent ,
                     keysManager ) ;

   // Create a placement manager
   BdbRefAny hint( dbH ) ;
   BdbAbsPlacementManager* placementManager( new BdbScribeChkPlaceMgr( "tst" ,
                                                                       "one" ,
                                                                       hint ) ) ;

   // Create a transient representation of objects and place then
   //   in the transient event.
   BdbScribeChkClass* objectOne( new BdbScribeChkClass( 0 ,
                                                        10 ,
                                                        1.0 ) ) ;
   BdbScribeChkClass* objectTwo( new BdbScribeChkClass( objectOne ,
                                                        20 ,
                                                        2.0 ) ) ;
   objectOne->setAssociation( objectTwo ) ;

   IfdStrKey key( "ObjectList" ) ;
   HepAList< BdbScribeChkClass>* list( 0 ) ;
   getTmpAList( transEvent ,
                list ,
                key ) ;
   list->append( objectOne ) ;
   list->append( objectTwo ) ;

   ErrMsg( routine ) << "Objects to be output to the Federation:"
                     << endmsg ;
   const size_t finished = list->length() ;
   for( size_t outIndex( 0 ) ;
        finished != outIndex ;
        ++outIndex ) {
      ErrMsg( routine ) << (*(*list)[ outIndex ])
                        << endmsg ;
   }

   // Create a conversion manager.
   size_t highestInputCount( 0 ) ;
   size_t highestOutputCount( 0 ) ;
   size_t* inputHigh( &highestInputCount ) ;
   size_t* outputHigh( &highestOutputCount ) ;
   BdbConversionManager* manager( new BdbConversionManager( inputHigh ,
                                                            outputHigh ) ) ;

   // Create an register for output with the conversion manager
   //   a Scribe which can convert the transient representation
   //   into a persistent one.
   BdbGenericScribe* scribe( new BdbCompositeScribe< BdbScribeChkClass , BdbScribeChkCompositeP_000 >( key ,
                                                                                                       "tst" ,
                                                                                                       "one" ) ) ;
   manager->addScribeForOutput( *scribe ) ;

   // Use the conversion manager to output the transient
   //   representation.
   manager->convertToPersistent( *transEvent ,
                                 *placementManager ,
                                 eventT ) ;

   // Commit transaction and start a new one.
   gTransaction.commit() ;
   gTransaction.start() ;
   if ( ! fd_begin() ) {
      ErrMsg( fatal ) << "Failed to open Federated Database."
                      << endmsg ;
      exit( -1 ) ;
   }

   // Delete transient event and create a new one.
   delete transEvent ;
   transEvent = new AbsEvent ;


   // Delete conversion manager and create a new one.
   delete manager ;
   manager = new BdbConversionManager( inputHigh ,
                                       outputHigh ) ;

   // Delete old scribe and then create and register for input with the
   //   conversion manager a Scribe which can convert the most recent
   //   persistent representation into a transient one.
   delete scribe ;
   scribe = new BdbCompositeScribe< BdbScribeChkClass , BdbScribeChkCompositeP_001 >( key ,
                                                                                      "tst" ,
                                                                                      "one" ) ;
   manager->addScribeForInput( *scribe ) ;

   // Use the conversion manager to input the transient representation.
   manager->convertToTransient( eventT ,
                                *transEvent ) ;

   // Commit the transaction.
   gTransaction.commit() ;

   // Check that the transient representation have been correctly restore.
   getTmpAList( transEvent ,
                list ,
                key ) ;
   ErrMsg( routine ) << "Results of input from the Federation:"
                     << endmsg ;
   for( size_t inIndex( 0 ) ;
        finished != inIndex ;
        ++inIndex ) {
      ErrMsg( routine ) << (*(*list)[ inIndex ])
                        << endmsg ;
   }
         
   // clean up
   delete scribe ;
   delete manager ;
   // "objectOne"& "objectTwo" cleaned up by AbsEvent
   delete placementManager ;
   // "persEvent" cleaned up by Objy
   delete transEvent ;

   // Write out summary of ConversionManager
   ErrMsg( routine ) << "The highest input count was "
                     << highestInputCount
                     << endmsg ;
   ErrMsg( routine ) << "The highest output count was "
                     << highestOutputCount
                     << endmsg ;

   return ( 0 ) ;
}

#endif // TSTMANYTOONE_CC

 

---

BaBar Public Site | SLAC | News | Links | Who's Who | Contact Us

Page Owner: Jacek Becla
Last Update: October 04, 2002