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

                 

---

/BdbCondTests/PerfTest3.cc

Go to the documentation of this file.

//-----------------------------------------------------------------------------
//
// File and Version Information:
//      $Id: PerfTest3.cc,v 1.8 2002/08/07 21:51:59 gapon Exp $
//
// Description:
//      A program developed to measure time performance of BdbCond operations.
//
// Environment:
//      Software developed for the BaBar Detector at the SLAC B-Factory.
//
// Author List:
//      D.Bukin       Budker Institute of Nuclear Physics, Nsk, Russia.
//
// Copyright Information:
//      Copyright (C) 2000    Lawrence Berkeley Laboratory
//
//-----------------------------------------------------------------------------


// -------------------------
// -- Objectivity Headers --
// -------------------------
#include <ooIndex.h>

//-------------
// C Headers --
//-------------
extern "C" {
#include <limits.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <time.h>
#if (defined OO_SOLARIS)
# include <sys/time.h>
#endif
}

//--------------------
// C++ Headers -------
//--------------------

#include <iostream.h>
#include <iomanip.h>

//-------------------------------
// Collaborating Class Headers --
//-------------------------------

#include "BaBar/BaBar.hh"
#include "BdbUtil/Bdb.hh"
#include "BdbCond/BdbConditions.hh"
#include "BdbTime/BdbTime.hh"
#include "BdbCondTests/EmcFooClassP.hh"
#include "BdbCondTests/EmcFooClassP_001.hh"
#include "BdbCondTests/EmcFooClassP_002.hh"
#include "BdbCond/BdbObsoleteDatabase.hh"
#include "BdbCond/BdbCondDatabaseMgr.hh"
#include "BdbCond/BdbIntervalItr.hh"
#include "BdbCond/BdbIntervalR.hh"
#include "BdbCond/BdbCondStoreTime.hh"

#include "BdbApplication/BdbDebug.hh"

#include "rw/cstring.h"
#include "rw/tvordvec.h"
#include "rw/tvsrtvec.h"

RWBoolean debugMode = FALSE;
RWBoolean outputMode = TRUE;
RWBoolean declareTransactionAtStart = FALSE;

static long  timeToFind = 0;

#define DBG( x ) if (debugMode) cerr << x
#define DBGL( x ) if (debugMode) cerr << x << endl
#define DBGRES( x ) if ( debugMode ) cerr << (CMD_SUCCESS == x ? " ok" : (CMD_WARNING == x ? " warn" : " fail" )) << endl
#define OUTL( x, y ) if (outputMode) cout << x << ":== " << y << endl;
#define CLKOUT cout

//--------------------------------------------
// Exported and Local Variable Declarations --
//--------------------------------------------

static const char rcsid[] = "$Id: PerfTest3.cc,v 1.8 2002/08/07 21:51:59 gapon Exp $";

// command index type, CMD_WRONG must be the first
enum cmd_index {
    CMD_WRONG = 0,
    CMD_UNKNOWN,
    CMD_HELP,
    CMD_TRANSACTION,
    CMD_CONTAINERS,
    CMD_DELETE,
    CMD_CLEANUP,
    CMD_STORE,
    CMD_ANALYZE,
    CMD_TOGGLEANALYZE,
    CMD_TOGGLEDEBUG,
    CMD_TOGGLEOUTPUT,
    CMD_EXIT,
    CMD_SETCONTAINER,
    CMD_STOREVECTOR,
    CMD_STOREVECTORN,
    CMD_REPEAT,
    CMD_END,
    CMD_OFFSET,
    CMD_RANDOM,
    CMD_COPY,
    CMD_OFFSETLAST,
    CMD_TAG,
    CMD_STORE2,
    CMD_STORETRUNC,
    CMD_REMOVEHISTORY,
    CMD_SETINDEXMODE,
    CMD_SCAN,
    CMD_FINDINTERVAL,
    CMD_PURGE
};


// arg index type, ARG_UNKNOWN must be the first
enum arg_index {
    ARG_UNKNOWN = 0,
    ARG_BOOL,
    ARG_INT,
    ARG_STRING,
    ARG_TIME,
    ARG_DELTA,
    ARG_OBJECT1,
    ARG_OBJECT2,
    ARG_VECTOR,
    ARG_NOMORE
};


enum result {
    CMD_ERROR = 0,
    CMD_WARNING,
    CMD_SUCCESS
};


typedef struct {
  cmd_index     code;
  const char*   name;
  const char*   arguments;
  const char*   description;
  int           ismodifier;
} cmd;


typedef struct {
  arg_index     code;
  const char    name;
  const char*   description;
} arg;


// arg description list,  ARG_UNKNOWN MUST be the last
const arg argument_list[] = {
    { ARG_BOOL,    'b', "bool" },
    { ARG_INT,     'i', "int" },
    { ARG_STRING,  's', "string" },
    { ARG_TIME,    'T', "time" },
    { ARG_DELTA,   't', "delta" },
    { ARG_OBJECT1, 'o', "object1" },
    { ARG_OBJECT2, 'O', "object2" },
    { ARG_VECTOR,  'v', "objvector" },
    { ARG_NOMORE,  '\0', "nomore" },
    { ARG_UNKNOWN, ',', "unknown" }
};


//------------------------------------
//       function declaration
//------------------------------------

// print help
result cmd_help(const cmd* commands);

// start transaction. ensure can be:
//    0 - just ensure that in transaction;
//    1 - finish previous and start next;
//    2 - finish previous.
result cmd_transaction( RWBoolean updateMode = TRUE, int ensure = 0 );

// list containers
result cmd_containers(const RWCString& detector, std::vector<RWCString>* containerlist = 0);

// delete container
result cmd_delete( const RWCString& detector, const RWCString& container );

// store object by start time
result cmd_store(const RWCString& detector, const RWCString& container,
               const RWCString& object, const BdbTime& starttime );

// store object by two times
result cmd_store2(const RWCString& detector, const RWCString& container,
                  const RWCString& object, const BdbTime& starttime, const BdbTime& endtime );

// truncate and store object by two times
result cmd_storetrunc(const RWCString& detector, const RWCString& container,
                      const RWCString& object, const BdbTime& starttime, const BdbTime& endtime );

// set container
result cmd_setcontainer(const RWCString& newdetector, const RWCString& newcontainer,
                        RWCString& detector, RWCString& container );

// analyze container structure
result cmd_analyze(const RWCString& detector, const RWCString& container);

// store a vector of objects
result cmd_storevector(const RWCString& detector, const RWCString& container,
                       int elts,
                       RWTValOrderedVector<RWCString>& strings,
                       RWTValOrderedVector<BdbTime>& times );

// store a vector of uniformly located objects
result cmd_storevectorn(const RWCString& detector, const RWCString& container,
                        int elts, const RWCString& object,
                        const BdbTime& starttime, const BdbTime& offsettime );
                       
// clean up all containers
result cmd_cleanup( const RWCString& detector );

// copy container
result cmd_copy(const RWCString& detector, const RWCString& container,
                const RWCString& newdetector, const RWCString& newcontainer );


// remove history
result cmd_removehistory(const RWCString& detector, const RWCString& container );

// set offset to the begin time of the last interval
result cmd_offsetlast(const RWCString& detector, const RWCString& container,
                      long& offset );

// scan a container
result cmd_scan(const RWCString& detector, const RWCString& container,
                const BdbTime& intervaltime );

// find interval in a container
result cmd_findinterval(const RWCString& detector, const RWCString& container,
                        const BdbTime& intervaltime );

// purge a container
result cmd_purge(const RWCString& detector, const RWCString& container,
                 const BdbTime& starttime, const BdbTime& endtime,
                 long maxNumOfTop );

// toggle indexmode
result cmd_setindexmode(long mode);


// read a command from stream
int readCommand(const cmd*                      commands,
                RWTValOrderedVector<RWCString>& strings,
                RWTValOrderedVector<int>&       ints,
                RWTValOrderedVector<BdbTime>&   times,
                istream&                        in );
int popCommand(const cmd*                      commands,
               RWTValOrderedVector<RWCString>& strings,
               RWTValOrderedVector<int>&       ints,
               RWTValOrderedVector<BdbTime>&   times,
               RWTValOrderedVector<int>&       cmdstack,
               RWTValOrderedVector<RWCString>& strstack,
               RWTValOrderedVector<int>&       intstack,
               RWTValOrderedVector<BdbTime>&   timstack,
               int& icmd, int& istr, int& iint, int& itim);

// routime get/set time offset for new times
long timeOffset( long* newoffset = 0);





int main( int argc, char** argv ) {
  BdbConditions* theApp = BdbConditions::instance();

  RWCString detector("-");
  RWCString container("-");
  cmd_setcontainer( detector, container, detector, container );

  // command bank, CMD_EXIT MUST be the first,
  // CMD_UNKNOWN must separate true commands from pseudo-commands 
  static const cmd commands[] = {
      { CMD_EXIT, "exit", "",
          "\t\texit program", 0},
      { CMD_HELP, "help", "",
          "\t\tgetting help", 0 },
      { CMD_SETCONTAINER, "setcontainer", "sdatabase,scontainer",
          "\t\tset current detector and container,\n\t\tthat will be used by other commands;", 0},
      { CMD_TRANSACTION, "transaction", "",
          "\t\tfinish active transaction\n\t\tthe next transaction will be started automatically;", 0 },
      { CMD_CONTAINERS, "containers", "",
          "\t\tlist containers in the current detector;", 0 },
      { CMD_DELETE, "delete", "",
          "\t\tdelete current container.  More than two delete \n\t\ton the same container per session does not work;", 1},
      { CMD_CLEANUP, "cleanup", "",
          "\t\tdelete all the containers from detector;", 0 },
      { CMD_STORE, "store", "oobject",
          "\t\tstore an object by start time;", 1},
      { CMD_STORE2, "store2", "Oobject",
          "\t\tstore an object by start and end times;", 1},
      { CMD_STORETRUNC, "storetrunc", "Oobject",
          "\t\ttrunc and store an object by start and end times;", 1},
      { CMD_STOREVECTOR, "storevector", "vvector",
          "\t\tstore a vector of objects;", 1},
      { CMD_STOREVECTORN, "storevectorn", "ielts,Oobject",
          "\t\tstore a vector of objects;", 1},
      { CMD_ANALYZE, "analyze", "",
          "\t\tanalyze the structure of the container;", 0},
      { CMD_TOGGLEANALYZE, "toggleanalyze", "",
          "\t\ttoggle autoanalyze mode;", 0},
      { CMD_TOGGLEDEBUG, "toggledebug", "",
          "\t\ttoggle debug mode;", 0},
      { CMD_TOGGLEOUTPUT, "toggleoutput", "",
          "\t\ttoggle output mode;", 0},
      { CMD_REPEAT, "repeat", "ihowmany",
          "\t\trepeat commands several times;", 0},
      { CMD_END, "end", "",
          "\t\tends the repetetion.  Number of end commands\n\t\tshould match that of repeat ones.", 0},
      { CMD_RANDOM, "random", "isecmin,isecmax",
          "\t\tset additional random offset for all times", 0},
      { CMD_OFFSET, "offset", "iseconds",
          "\t\tchange offset to the delta seconds, if delta=0, then reset offset to 0", 0},
      { CMD_COPY, "copy", "solddetector,soldcontainer",
          "\t\tcopy from container", 1},
      { CMD_OFFSETLAST, "offsetlast", "",
          "\t\tset offset to the begin time of the last interval", 0},
      { CMD_TAG, "tag", "stag",
          "\t\tplace the string tag to the output", 0},
      { CMD_REMOVEHISTORY, "removehistory", "",
          "\t\tremove the history", 0},
      { CMD_SCAN, "scan", "Ttime",
          "\t\tscan container", 0},
      { CMD_FINDINTERVAL, "findinterval", "Ttime",
          "\t\tfind interval in container", 0},
      { CMD_SETINDEXMODE, "setindexmode", "imode",
          "\t\tset index mode: 0-explicit, 1-insense, 2-sense", 0},
      { CMD_PURGE, "purge", "Tstart,tend,itoplayers",
          "\t\tpurge container keeping number of top layers", 1},
      { CMD_UNKNOWN, 0, 0, 0, 0 },
      { CMD_WRONG, 0, 0, 0, 0 }
  };

  RWBoolean autoAnalyze = FALSE;


  // main loop over commands
  // readmode:
  //  0 -- read-and-fire mode
  //  1 -- accumulation mode (commands are read and stored into the storages below)
  //  2 -- discharge mode (commands are taken from storages and executed)
  int readmode = 0;

  // --- only for accumulation/discharge mode: the storages
  RWTValOrderedVector<int>       repstack;   // keeps pointers to repeat command position in cmdstack
  RWTValOrderedVector<int>       endstack;   // keeps number of passes executed for each repeat command
  RWTValOrderedVector<int>       cmdstack;   // keeps commands for repetition mode
  RWTValOrderedVector<RWCString> strstack;   // >
  RWTValOrderedVector<int>       intstack;   //   > -- arguments
  RWTValOrderedVector<BdbTime>   timstack;   // >
  int icmd =0, istr =0, iint =0, itim =0;    // current pointers
  int nestlevel = 0;                         // how deep nesting

  // place to move argument of commands before execution
  RWTValOrderedVector<RWCString> strings;
  RWTValOrderedVector<int> ints;
  RWTValOrderedVector<BdbTime> times;

  while ( true ) {

    int idx = CMD_EXIT;

    // reading or popping a command
    if ( readmode == 2 ) { // discharge mode
      
      idx = popCommand(commands, strings, ints, times,
                       cmdstack, strstack, intstack, timstack,
                       icmd, istr, iint, itim);
      
    } else {

      if ( 1 == readmode ) {
        istr = strstack.length();
        itim = timstack.length();
        iint = intstack.length();
      }

      idx = readCommand(commands, strings, ints, times, cin);
      // when the command is read,
      // its arguments are placed into strings, times and ints arrays.
      // if it is the repetition command then repetition mode is
      // switched on.
      // in repetition mode, the command is placed into the cmdstack array.
      // repetition command also place the pointer to cmdstack
      // into repstack and then saves pointers to ints, strings and times
      // array onto cmdstack. the level of repetition is incremented.
      // the value of 0 is placed into endstack.
      // if the command is end command (that finish the repeat command),
      // then it decrement the repetition level.
      // When the repetition level is goes to 0, then begins the execution
      // of the loop.

      if ( CMD_REPEAT == commands[idx].code ) {
        if ( 1 != readmode ) {
          cmdstack.clear();
          strstack.clear();
          intstack.clear();
          timstack.clear();
          icmd = 0;
          istr = 0;
          iint = 0;
          itim = 0;
        }
        readmode = 1;
      }

    } // end of reading



    // postprocessing command
    if ( 1 == readmode ) { // in accumulation mode
      
      // put a command and its arguments into the store
      cmdstack.insert( idx );
      int i;
      for ( i = 0; i < ints.length(); i++ ) {
        intstack.insert(ints[i]);
      }
      for ( i = 0; i < strings.length(); i++ ) {
        strstack.insert(strings[i]);
      }
      for ( i = 0; i < times.length(); i++ ) {
        timstack.insert(times[i]);
      }

      if ( CMD_REPEAT == commands[idx].code ) {

        cmdstack.insert( iint );
        cmdstack.insert( istr );
        cmdstack.insert( itim );
        ++nestlevel;

      } else if ( CMD_END == commands[idx].code ) {

        --nestlevel;
        if ( 0 == nestlevel ) {
          // switch to discharge
          readmode = 2;
          icmd = 0;
          iint = 0;
          istr = 0;
          itim = 0;
        }

      }
      


    } else { // not in accumulation mode


      // applying additional offset to times
      int i;
      for ( i = 0; i < times.length(); i++ ) {
        if ( times[i] != BdbTime::minusInfinity &&
            times[i] != BdbTime::plusInfinity ) {
          times[i] = BdbTime(times[i].getGmtSec() + timeOffset());
          if ( times[i] == BdbTime::minusInfinity ) times[i] = BdbTime(times[i].getGmtSec()+1);
          if ( times[i] == BdbTime::plusInfinity ) times[i] = BdbTime(times[i].getGmtSec()-1);
        }
      }

      // here is the execution code for commands
      result status = CMD_SUCCESS;
      switch ( commands[idx].code ) {

       case CMD_REPEAT: {
         while ( repstack.length() <= nestlevel ) {
           repstack.insert(0);
         }
         while ( endstack.length() <= nestlevel ) {
           endstack.insert(0);
         }
         repstack[nestlevel] = icmd - 1;
         iint = cmdstack[icmd++];
         istr = cmdstack[icmd++];
         itim = cmdstack[icmd++];
         if ( 0 == endstack[nestlevel] ) {
           // initialize the loop
           DBGL( "entering loop at lev#" << nestlevel << ", N = " << intstack[iint] );
           endstack[nestlevel] = intstack[iint];
         }
         OUTL("rep" << nestlevel, intstack[iint]-endstack[nestlevel] );
         ++iint;
         ++nestlevel;
         break;
       }
       case CMD_END: {
         --nestlevel;
         --endstack[nestlevel];
         if ( 0 == endstack[nestlevel] ) {
           // the loop has been finished
           DBGL( "finishing loop at lev#" << nestlevel );
           if ( 0 == nestlevel ) {
             readmode = 0;
           }
         } else { // go on to the start
           icmd = repstack[nestlevel];
           iint = cmdstack[icmd+1];
         }
         break;
       }

       case CMD_UNKNOWN: {
         DBGL( "unknown" );
         status = CMD_WARNING;
         break;
       }

       case CMD_WRONG: {
         cerr << "wrong arguments" << endl;
         status = CMD_WARNING;
         break;
       }
       case CMD_HELP: {
         cmd_help( commands );
         break;
       }
  
       case CMD_TRANSACTION: {
         status = cmd_transaction( TRUE, 2 );
         break;
       }
  
       case CMD_CONTAINERS: {
         status = cmd_containers( detector );
         break;
       }
  
       case CMD_DELETE: {
         status = cmd_delete( detector, container );
         break;
       }
  
       case CMD_CLEANUP: {
         status = cmd_cleanup( detector );
         break;
       }
  
       case CMD_STORE: {
         status = cmd_store( detector, container, strings(0), times(0) );
         break;
       }
  
       case CMD_STORE2: {
         status = cmd_store2( detector, container, strings(0), times(0), times(1) );
         break;
       }
  
       case CMD_STORETRUNC: {
         status = cmd_storetrunc( detector, container, strings(0), times(0), times(1) );
         break;
       }
  
       case CMD_ANALYZE: {
         status = cmd_analyze( detector, container );
         break;
       }
  
       case CMD_TOGGLEANALYZE: {
         autoAnalyze = TRUE - autoAnalyze;
         cout << "autoanalyze mode is " << ( autoAnalyze ? "ON" : "OFF" ) << endl;
         break;
       }
  
       case CMD_TOGGLEDEBUG: {
         debugMode = TRUE - debugMode;
         // DBGL( "debug mode is " << ( debugMode ? "ON" : "OFF" ) );
         break;
       }
  
       case CMD_TOGGLEOUTPUT: {
         outputMode = TRUE - outputMode;
         // DBGL( "output mode is " << ( newOutputMode ? "ON" : "OFF" ) );
         break;
       }
  
       case CMD_EXIT: {
         status = cmd_transaction(FALSE,2);
         break;
       }
  
       case CMD_SETCONTAINER: {
         status = cmd_setcontainer( strings(0), strings(1), detector, container );
         OUTL("contain ", container );
         break;
       }
        
       case CMD_STOREVECTOR: {
         status = cmd_storevector( detector, container, ints(0), strings, times );
         break;
       }

       case CMD_STOREVECTORN: {
         status = cmd_storevectorn( detector, container, ints(0),
                                   strings(0), times(0), times(1) );
         break;
       }

       case CMD_RANDOM: {
         double f = double(random())/LONG_MAX;
         if ( f < 0 || f > 1 ) {
           cerr << "wrong random number: " << f << endl;
           exit(1);
         }
         long offset = (ints(1)-ints(0))*f;
         timeOffset(&offset);
         break;
       }

       case CMD_OFFSET: {
         long offset = ints(0);
         if ( offset != 0 ) offset += timeOffset();
         timeOffset(&offset);
         break;
       }

       case CMD_OFFSETLAST: {
         long offset;
         status = cmd_offsetlast( detector, container, offset );
         if ( CMD_SUCCESS == status ) timeOffset(&offset);
         break;
       }

       case CMD_SCAN: {
         status = cmd_scan( detector, container, times(0) );
         break;
       }

       case CMD_FINDINTERVAL: {
         status = cmd_findinterval( detector, container, times(0) );
         break;
       }

       case CMD_PURGE: {
         status = cmd_purge( detector, container, times(0), times(1), ints(0));
         break;
       }

       case CMD_SETINDEXMODE: {
         status = cmd_setindexmode(ints(0));
         break;
       }

       case CMD_COPY: {
         status = cmd_copy(strings(0), strings(1), detector, container);
         break;
       }

       case CMD_TAG: {
         if ( outputMode ) {
           cout << strings(0) << endl;
         }
         break;
       }

       case CMD_REMOVEHISTORY: {
         status = cmd_removehistory( detector, container );
         break;
       }

       default: {
         cout << "not implemented" << endl;
         status = CMD_WARNING;
       }
  
      }
  
      if ( CMD_ERROR == status ) {
        cmd_transaction(TRUE,-1);
        return 1;
      }

      if ( commands[idx].code == CMD_EXIT ) break;

      if (autoAnalyze && 
        status == CMD_SUCCESS &&
        commands[idx].ismodifier ) {
        cmd_analyze(strings(0), strings(1));
      }

    } // not in accumulation mode

  }
  return 0;
}





RWCString translateOID( const BdbRefAny& ref ) {
  ooId id = ref;
  d_UShort db   = id.get_DB();
  d_UShort cont = id.get_OC();
  d_UShort page = id.get_page();
  d_UShort slot = id.get_slot();
  char s[256];

  sprintf( s, "%d-%d-%d-%d", (int) db, (int) cont, (int) page, (int) slot );
  return s;
}


RWCString translateSOID( const BdbRefAny& ref ) {
  ooId id = ref;
  d_UShort page = id.get_page();
  d_UShort slot = id.get_slot();
  char s[256];

  sprintf( s, "%d-%d", (int) page, (int) slot );
  return s;
}


int readArg( const char c ) {
  int idx = 0;
  while ( argument_list[idx].code != ARG_UNKNOWN && argument_list[idx].name != c ) {
    ++idx;
  }
  return idx;
}



int nextArgument( RWCString& argstring, RWCString& argname ) {

  // skip commas
  int skip = 0;
  const char* p = argstring.data();
  while ( p[skip] == ',' ) ++skip;
  if ( skip ) argstring = argstring(skip,argstring.length()-skip);
  if ( 0 == argstring.length() ) return readArg('\0');

  // get argument type
  int argtype = readArg(argstring(0));

  // get argument name
  skip = argstring.first(',',1);
  if ( RW_NPOS == skip ) skip = argstring.length();
  argname = argstring(1,skip-1);
  argstring = argstring(skip,argstring.length()-skip);

  return argtype;
}






int readCommand(const cmd*                      commands,
                RWTValOrderedVector<RWCString>& strings,
                RWTValOrderedVector<int>&       ints,
                RWTValOrderedVector<BdbTime>&   times,
                istream&                        in ) {

  static const BdbTime zeroTime(1996,1,1,0,0,0);
  static BdbTime lastTime = zeroTime;

  RWCString cmd_name;
  if ( ! in ) return 0;

  in >> cmd_name;
  int idx = 0;
  while ( commands[idx].code != CMD_UNKNOWN &&
         commands[idx].name != cmd_name ) {
    ++idx;
  }
  // clean up arguments
  ints.clear();
  strings.clear();
  times.clear();

  if ( commands[idx].code == CMD_UNKNOWN ) {

    cerr << "unknown command:" << cmd_name << endl;
    
  } else {

    // DBGL("=== next command: " << commands[idx].name );

    // read arguments
    RWCString argstring = commands[idx].arguments;
    while ( true ) {

      RWCString argname;
      int argtype = nextArgument(argstring, argname);
      if ( ARG_NOMORE == argument_list[argtype].code ) break;

      // read argument
      switch ( argument_list[argtype].code ) {
       case ARG_BOOL: { // bool
         RWBoolean b;
         in >> b;
         if ( b != TRUE && b != FALSE ) return CMD_WRONG;
         ints.insert(b);
         break;
       }
       case ARG_INT: { // int
         int n;
         in >> n;
         ints.insert(n);
         break;
       }
       case ARG_STRING: { // RWCString
         RWCString s;
         in >> s;
         strings.insert(s);
         break;
       }
       case ARG_TIME:
       case ARG_DELTA: {
         RWCString s;
         in >> s;
         int len = 1;
         BdbTime t;
         switch ( s[0] ) {
          case 'm': {
            t = BdbTime::minusInfinity;
            break;
          }
          case 'p': {
            t = BdbTime::plusInfinity;
            break;
          }
          case 'z': {
            t = zeroTime;
            break;
          }
          case 'l': {
            t = lastTime;
            break;
          }
          default: {
            t = (ARG_TIME == argument_list[argtype].code ? zeroTime : lastTime );
            len = 0;
          }
         } // switch first letter of the time
         
         if ( s.length() > len ) {
           long dt = atol( s.data()+len );
           t = t + dt;
         }
         times.insert(t);
         lastTime = t;
         break;
       }
       case ARG_OBJECT1: {
         argstring.prepend("s,T,");
         break;
       }
       case ARG_OBJECT2: {
         argstring.prepend("s,T,t,");
         break;
       }
       case ARG_VECTOR: {
         int n;
         in >> n;
         if ( n < 1 ) {
           cerr << "vector must have positive number of elements." << endl;
           return CMD_WRONG;
         }
         ints.insert(n);
         argstring.prepend("t,");
         while ( n-- > 1 ) {
           argstring.prepend("s,t,");
         }
         argstring.prepend("s,T,");
         break;
       }
       default: {
         cerr << "unknown argument type:" << argument_list[argtype].name << endl;
         exit(1);
       }

      }

    } // while more arguments needed

  }
  return idx;
}






int popCommand(const cmd*                      commands,
               RWTValOrderedVector<RWCString>& strings,
               RWTValOrderedVector<int>&       ints,
               RWTValOrderedVector<BdbTime>&   times,
               RWTValOrderedVector<int>&       cmdstack,
               RWTValOrderedVector<RWCString>& strstack,
               RWTValOrderedVector<int>&       intstack,
               RWTValOrderedVector<BdbTime>&   timstack,
               int& icmd, int& istr, int& iint, int& itim) {

  if ( icmd >= cmdstack.length() ) {
    cerr << "too few commands on stack" << endl;
    exit(1);
  }

  int idx = cmdstack[icmd++];

  // clean up arguments
  ints.clear();
  strings.clear();
  times.clear();

  if ( commands[idx].code == CMD_UNKNOWN ) {

    abort();

  } else {

    // DBGL("=== next command: " << commands[idx].name );

    // read arguments
    RWCString argstring = commands[idx].arguments;
    while ( true ) {

      RWCString argname;
      int argtype = nextArgument(argstring, argname);
      if ( ARG_NOMORE == argument_list[argtype].code ) break;

      // read argument
      switch ( argument_list[argtype].code ) {
       case ARG_BOOL: { // bool
         int b = intstack[iint++];
         if ( b != TRUE && b != FALSE ) {
           cerr << "should be bool" << endl;
           exit(1);
         }
         ints.insert(b);
         break;
       }
       case ARG_INT: { // int
         ints.insert(intstack[iint++]);
         break;
       }
       case ARG_STRING: { // RWCString
         strings.insert(strstack[istr++]);
         break;
       }
       case ARG_TIME:
       case ARG_DELTA: {
         times.insert(timstack[itim++]);
         break;
       }
       case ARG_OBJECT1: {
         argstring.prepend("s,T,");
         break;
       }
       case ARG_OBJECT2: {
         argstring.prepend("s,T,t,");
         break;
       }
       case ARG_VECTOR: {
         int n = intstack[iint++];
         ints.insert(n);
         argstring.prepend("t,");
         while ( n-- > 1 ) {
           argstring.prepend("s,t,");
         }
         argstring.prepend("s,T,");
         break;
       }
       default: {
         cerr << "unknown argument type:" << argument_list[argtype].name << endl;
         exit(1);
       }

      }

    } // while more arguments needed

  }
  return idx;

}








result makeObject(const RWCString& detector,
                const RWCString& object,
                BdbHandle(BdbObject)& objH ) {
  result status = CMD_SUCCESS;

  if ( "-" == object ) {
    objH = NULL;
  } else {

    status = CMD_ERROR;

    while ( true ) {
      // DBGL( "making object" );

      if ( ! cmd_transaction(TRUE) ) break;

      BdbObsoleteDatabase db(detector);
      BdbRefAny hint = db.updatedHint();
      if ( BdbIsNull(hint) ) {
        cerr << "failed to get a hint" << endl;
        break;
      }
      // DBGL( "got a hint: [" << translateOID(hint) << "]");

      if ( "a" == object ) {
        objH = new(hint) EmcFooClassP( EmcFooClass(random()) );
      } else if ( "b" == object ) {
        objH = new(hint) EmcFooClassP_001( EmcFooClass_001(random(),random()) );
      } else if ( "c" == object ) {
        objH = new(hint) EmcFooClassP_002( EmcFooClass_002(random(),random(),random()) );
      } else {
        cerr << "wrong object name " << object << endl;
        status = CMD_WARNING;
        break;
      }

      if ( BdbIsNull(objH) ) {
        cerr << "failed to create object" << endl;
        break;
      }
    
      // DBGL( "object has been created [" << translateOID(objH) << "]" );
      status = CMD_SUCCESS;
      break;
    }
  }
  return status;
}







long timeOffset( long* newoffset ) {
  static long offset = 0;
  if ( newoffset ) {
    offset = *newoffset;
    // DBGL("new offset is: " << timeOffset());
  }
  return offset;
}







//===========================
//       print help
//===========================
result cmd_help( const cmd* commands ) {
  const cmd* p = commands;
  cout << "Commands are:" << endl;
  while ( p->code != CMD_UNKNOWN ) {
    cout << p->name;
    RWCString argstring = p->arguments;
    while ( true ) {
      RWCString argname;
      int argtype = nextArgument(argstring, argname);
      if ( ARG_NOMORE == argument_list[argtype].code ) break;
      cout << " " << argname << "(" << argument_list[argtype].description << ")";
    }
    cout << endl << p->description << endl;
    ++p;
  }
  return CMD_SUCCESS;
}







static long getMillis()
{
    long millis = 0;
#if (defined OO_SOLARIS)
    struct timeval tv;
    gettimeofday( &tv, 0 );
    millis = tv.tv_sec * 1000 + tv.tv_usec/1000;
#endif
    return millis;
}





//===========================
//      new transaction
//===========================
result cmd_transaction( RWBoolean updateMode, int ensure ) {
  static RWBoolean inTransaction = FALSE;
  static RWBoolean mode = FALSE;
  static clock_t usecs;
  static long msecs;

  BdbConditions* theApp = BdbConditions::instance();

  // abort current transaction
  if ( ensure < 0 ) {
    if ( inTransaction ) {
      DBGL( "-> abort" );
      theApp->abort();
    }
    exit(1);
  }

  // finish previous transaction if explicitly asked or update mode needed being in readonly
  if ( inTransaction && ( ensure != 0 || updateMode && !mode ) ) {

    // DBGL("finishing the old transaction of mode " << mode );
    DBG( "-> transcomm" );

    CLKOUT << "cmd_transaction: committing..." << endl;
    if ( BdbcSuccess != theApp->commit() ) {
      cerr << " failed to commit transaction" << endl;
      return CMD_ERROR;
    }
    CLKOUT << "cmd_transaction: ...committed" << endl;

    clock_t ttclock = clock() / 1000;
    usecs = ttclock - usecs;
    msecs = getMillis() - msecs;

    // calibration
    clock_t calstart = clock();
    clock_t caltime;
    int nloop = 0;
    while ( (caltime = clock() - calstart) < 1000000 ) {
      int j = 0;
      for ( int i = 0; i < 1000; i++ ) {
        j += 1;
      }
      nloop += 1;
    }

    OUTL("calibr  ", nloop/(((double)caltime)/1000) );
    OUTL("ttsystem", usecs );
    OUTL("ttastro ", msecs );
    OUTL("ttfind  ", timeToFind );


    // shows the current time since
    static time_t ttstartrun = 0;
    if ( 0 == ttstartrun ) {
      struct tm t;
      t.tm_sec = 0;
      t.tm_min = 0;
      t.tm_hour = 0;
      t.tm_mday = 1; // 1st
      t.tm_mon = 8;  // september
      t.tm_year = 100;
      t.tm_isdst = 0;
      ttstartrun = mktime( &t );
    }
    double ttrun = (time(0) - ttstartrun) / (double)86400.0;
    OUTL("ttrun   ", ttrun );

    if ( outputMode && !declareTransactionAtStart ) {
      cout << "---endtransaction---" << endl;
    }

    inTransaction = FALSE;
    DBGRES( CMD_SUCCESS );

  }


  // start new transaction
  if ( ensure < 2 && ! inTransaction ) {

    usecs = clock()/1000;
    msecs = getMillis();
    timeToFind = 0;

    CLKOUT << "cmd_transaction: starting..." << endl;

    BdbStatus status = updateMode ? theApp->startUpdate() : theApp->startRead();
    if ( BdbcSuccess != status ) {
      cerr << "failed to start a new transaction" << endl;
      return CMD_ERROR;
    }

    CLKOUT << "cmd_transaction: ...started" << endl;

    mode = updateMode;
    inTransaction = TRUE;

    if ( outputMode && declareTransactionAtStart ) {
      cout << "---newtransaction---" << endl;
    }

  }
  return CMD_SUCCESS;

}






//===========================
//       print containers
//===========================
result cmd_containers( const RWCString& detector, std::vector<RWCString>* containerlist ) {

  DBG( "-> containers" );
  result status = cmd_transaction(TRUE);

  do {

    if ( CMD_SUCCESS != status ) {
      break;
    }

    // list all containers
    std::vector<std::string> containers;
    BdbObsoleteDatabase db(detector);
    /*
    if ( BdbcSuccess != db.listAllClasses( containers, true ) ) {
      cerr << "cannot list old intervals" << endl;
      status = CMD_WARNING;
      break;
    }
     */
    if ( BdbcSuccess != db.listAllClasses( containers, false, true ) ) {
      cerr << "cannot list new intervals" << endl;
      status = CMD_WARNING;
      break;
    }

    if ( 0 != containerlist ) {
      (*containerlist).clear();
      for ( int i = 0; i < containers.size(); i++ ) {
        (*containerlist).push_back( RWCString( containers[i].c_str()));
      }
    } else {
      cout << "containers are:" << endl;
      for ( int i = 0; i < containers.size(); i++ ) {
        cout << "   " << containers[i].c_str() << endl;
      }
    }

  } while ( 0 );

  DBGRES( status );
  return status;
}







//===========================
//       delete database
//===========================
result cmd_delete( const RWCString& detector, const RWCString& container ) {
  BdbCondDatabaseMgr mgr;

  DBG( "-> delete" );
  result status = cmd_transaction(TRUE);

  do {
    
    if ( CMD_SUCCESS != status ) {
      break;
    }

    if ( BdbcSuccess != mgr.removeIntervalContainer(detector, container, true) ) {
      cerr << "failed to delete container" << endl;
      status = CMD_WARNING;
      break;
    }

  } while ( 0 );

  DBGRES( status );
  return status;
}







//===========================
//       cleanup database
//===========================
result cmd_cleanup( const RWCString& detector ) {
  std::vector<RWCString> containerlist;

  DBG( "-> cleanup" );
  result status = cmd_containers(detector, &containerlist);
  
  do {

    for ( int i = 0; i < containerlist.size() && CMD_SUCCESS == status ; i++ ) {
      status = cmd_delete( detector, containerlist[i] );
    }

  } while (0);

  DBGRES( status );
  return status;
}




//=====================================
//       copy container
//=====================================
result cmd_setindexmode( long mode ) {
/*
  BdbConditions* theApp = BdbConditions::instance();
  switch ( mode ) {
   case 0:
    theApp->setIndexMode( oocExplicitUpdate );
    break;
   case 1:
    theApp->setIndexMode( oocInsensitive );
    break;
   case 2:
    theApp->setIndexMode( oocSensitive );
    break;
   default:
    cerr << "unknown index mode" << endl;
    return CMD_WARNING;
  }
  return CMD_SUCCESS;
*/
  cerr << "index mode manipulation is not available in the core code of" << endl
       << "of the BDB libraries." << endl;
  return CMD_WARNING;
}



//=====================================
//       copy container
//=====================================
result cmd_copy(const RWCString& olddetector, const RWCString& oldcontainer,
                const RWCString& newdetector, const RWCString& newcontainer ) {
  BdbCondDatabaseMgr mgr;

  DBG( "-> copy from " << olddetector << " " << oldcontainer );
  result status = CMD_SUCCESS;

  do {
    if ( CMD_SUCCESS != cmd_transaction(TRUE) ) {
      status = CMD_ERROR;
      break;
    }

    if ( BdbcSuccess != mgr.copyIntervalContainer(olddetector,
                                                  oldcontainer,
                                                  newdetector,
                                                  newcontainer) ) {
      cerr << "failed to copy container" << endl;
      status = CMD_WARNING;
      break;
    }

  } while ( 0 );

  DBGRES( status );
  return status;
}




//=====================================
// remove history
//=====================================
result cmd_removehistory(const RWCString& detector, const RWCString& container ) {

  DBG( "-> removehistory" );
  result status = cmd_transaction(TRUE);

  do {

    if ( CMD_SUCCESS != status ) break;

    BdbCondDatabaseMgr mgr;
    if ( BdbcSuccess != mgr.removeHistory( detector, container ) ) {
      status = CMD_WARNING;
      break;
    }

  } while ( 0 );

  DBGRES( status );
  return status;
}


//=====================================
// set offset to the begin time of the last interval
//=====================================
result cmd_offsetlast(const RWCString& detector, const RWCString& container,
                      long& offset ) {
  static BdbTime zeroTime(1996,1,1,0,0,0);

  DBG( "-> offsetlast" );
  result status = cmd_transaction(TRUE);

  do {
    if ( status != CMD_SUCCESS ) {
      break;
    }
    BdbObsoleteDatabase db(detector);
    BdbHandle(BdbInterval) last;

    if ( BdbcSuccess != db.lastInterval(last, container ) ) {
      status = CMD_WARNING;
      break;
    }

    offset = last->getBeginTime().getGmtSec() - zeroTime.getGmtSec();

  } while ( 0 );

  DBGRES( status );
  return status;
}



//=====================================
//       scan a container
//=====================================
result cmd_purge(const RWCString& detector, const RWCString& container,
                 const BdbTime& start, const BdbTime& end,
                 long maxtop ) {

  DBG( "-> purge" );
  result status = cmd_transaction(TRUE);

  do {

    if ( CMD_SUCCESS != status ) {
      break;
    }
  
    BdbCondDatabaseMgr mgr( true );
    if ( BdbcSuccess != mgr.purgeIntervalContainer( detector,
                                                   container,
                                                   start, end,
                                                   false,
                                                   maxtop ) ) {
      cerr << "cannot purge container" << endl;
      status = CMD_WARNING;
      break;
    }

  } while ( 0 );

  DBGRES( status );
  return status;
}



//=====================================
//       scan a container
//=====================================
result cmd_scan(const RWCString& detector, const RWCString& container,
                const BdbTime& theTime ) {

  DBG( "-> scan " << theTime.getGmtSec() );
  result status = cmd_transaction(TRUE);

  do {

    if ( CMD_SUCCESS != status ) {
      break;
    }

    BdbObsoleteDatabase db(detector);
    BdbHandle(BdbInterval) intH;
    if ( BdbcSuccess != db.firstInterval( intH, container ) ) {
      status = CMD_WARNING;
      break;
    } else if ( intH->inInterval(theTime) ) {
      status = CMD_SUCCESS;
      break;
    } else if ( BdbcSuccess != db.lastInterval( intH, container ) ) {
      status = CMD_WARNING;
      break;
    } else if ( intH->inInterval(theTime) ) {
      status = CMD_SUCCESS;
      break;
    } else;
    
    BdbHandle(BdbContObj) intervalContainerH;
    db.getIntervalContH( intervalContainerH );

    d_ULong gmtTime = theTime.getGmtSec();
    ooLookupKey lookupKey( ooTypeN(BdbInterval), 2 );

    ooLessThanEqualLookupField lessThanEqual( ooTypeN(BdbInterval),
                                             "_beginTime._gmtSec",
                                             & gmtTime );
    lookupKey.addField( lessThanEqual );

    ooGreaterThanLookupField greaterThan( ooTypeN(BdbInterval),
                                         "_endTime._gmtSec",
                                         & gmtTime );
    lookupKey.addField( greaterThan );

    BdbItr(BdbInterval) theIntervalItr;
    theIntervalItr.scan( intervalContainerH, lookupKey, BdbcRead );

  } while ( 0 );

  DBGRES( status );
  return status;
}




//=====================================
//       find interval in a container
//=====================================
result cmd_findinterval(const RWCString& detector, const RWCString& container,
                        const BdbTime& theTime ) {

  DBG( "-> findinterval " << theTime.getGmtSec() );
  result status = cmd_transaction(TRUE);

  do {

    if ( CMD_SUCCESS != status ) {
      break;
    }

    BdbObsoleteDatabase db(detector);
    BdbHandle(BdbInterval) intH;
    if ( BdbcSuccess != db.findInterval( intH,
                                         container,
                                         theTime ) ) {
      status = CMD_WARNING;
      break;
    }

  } while ( 0 );

  DBGRES( status );
  return status;
}



//=====================================
//       store object by start time
//=====================================
result cmd_store(const RWCString& detector, const RWCString& container,
               const RWCString& object, const BdbTime& starttime ) {
  BdbHandle(BdbObject) objH;

  DBG( "-> store1 " << starttime.getGmtSec() );
  result status = makeObject(detector, object, objH);

  do {

    if ( CMD_SUCCESS != status ) break;

    BdbObsoleteDatabase          db( detector );
    if ( BdbcSuccess != db.store( objH, container, starttime ) ) {
      cerr << "failed to store" << endl;
      status = CMD_ERROR;
      break;
    }

  } while ( 0 );

  DBGRES( status );
  return status;
}






//=====================================
//       store2 object by start and end time
//=====================================
result cmd_store2(const RWCString& detector, const RWCString& container,
                  const RWCString& object, const BdbTime& starttime,
                  const BdbTime& endtime ) {
  BdbHandle(BdbObject) objH;

  DBG( "-> store2 " << starttime.getGmtSec() << ":" << endtime.getGmtSec() );
  result status = makeObject(detector, object, objH);

  do {

    if ( CMD_SUCCESS != status ) break;

    BdbObsoleteDatabase db( detector );
    if ( BdbcSuccess != db.store( objH, container, starttime, endtime ) ) {
      cerr << "failed to store2" << endl;
      status = CMD_ERROR;
      break;
    }
  } while ( 0 );

  DBGRES( status );
  return status;

}






//=====================================
//       storeAndTruncate object
//=====================================
result cmd_storetrunc(const RWCString& detector, const RWCString& container,
                      const RWCString& object, const BdbTime& starttime,
                      const BdbTime& endtime ) {
  BdbHandle(BdbObject) objH;

  CLKOUT << "cmd_storetrunc: just entered" << endl;
  // DBG( "-> storetrunc " << starttime.getGmtSec() << ":" << endtime.getGmtSec() );
  result status = makeObject(detector, object, objH);

  CLKOUT << "cmd_storetrunc: object made" << endl;

  do {

    if ( CMD_SUCCESS != status ) break;

    BdbObsoleteDatabase  db( detector );
    if ( BdbcSuccess != db.storeAndTruncate( objH, container, starttime, endtime ) ) {
      cerr << "failed to storetrunc" << endl;
      status = CMD_ERROR;
    }

  } while ( 0 );

  DBGRES( status );
  CLKOUT << "cmd_storetrunc: leaving..." << endl;
  return status;

}






//=====================================
//           set container
//=====================================
result cmd_setcontainer(const RWCString& newdetector, const RWCString& newcontainer,
                        RWCString& detector, RWCString& container ) {
  if ( newdetector == "-" ) {
    detector = "emc";
  } else if ( newdetector.length() != 3 ) {
    cerr << "detector must be a 3 letter acronym." << endl;
    return CMD_WARNING;
  } else {
    detector = newdetector;
  }
  if ( newcontainer == "-" ) {
    container = "000000";
  } else {
    int dir = 0;
    if ( newcontainer == ">" ) {
      dir = 1;
    } else if ( newcontainer == "<" ) {
      dir = -1;
    }
    if ( dir ) {
      char tmp[40];
      unsigned long newcont = atol(container) + dir;
      sprintf(tmp,"%6.6d",newcont);
      container = tmp;
    } else {
      container = newcontainer;
    }
  }
  return CMD_SUCCESS;
}






result analyzeNode(BdbHandle(BdbIntervalR)& basenodeH, RWCString& rack,
                   long& currentnodes, long currentheight, long& currentwidth,
                   long& maxheight, long& avgheight ) {

  ++currentnodes;      // number of nodes at this baseline chunk
  ++currentheight;     // the height of this node

  BdbItr(BdbIntervalR) itr;
  
  DBG( "[" << translateSOID(basenodeH) << "]" );

  basenodeH.getNextVers(itr);
  RWCString thisrack = rack;
  thisrack.append(rack[rack.length()-1],1);

  long deltawidth = 0; // the width of that baseline level
  while ( itr.next() ) {

    ++deltawidth;
    BdbHandle(BdbIntervalR) nodeH( itr );

    if ( CMD_SUCCESS != analyzeNode(nodeH, thisrack,
                                    currentnodes, currentheight, currentwidth,
                                    maxheight, avgheight ) ) return CMD_WARNING;


  }

  if ( deltawidth ) {
    // there was the next level
    currentwidth += deltawidth - 1;
  } else {
    // nothing above
    DBGL( "" );
    DBGL( rack );
    if ( currentheight > maxheight ) maxheight = currentheight;
    avgheight += maxheight;
  }

  rack(rack.length()-1) ^= ('0' ^ 'X');
  return CMD_SUCCESS;
}




//=====================================
//       analyze the container
//=====================================
result cmd_analyze(const RWCString& detector, const RWCString& container) {

  DBGL( "-> analyze" );

  if ( CMD_SUCCESS != cmd_transaction() ) {
    return CMD_ERROR;
  }
  clock_t usecs = clock();
  long msecs = getMillis();
  result status = CMD_WARNING;

  do {

    BdbIntervalItr itr;
    if ( BdbcSuccess != itr.setBaseline(detector,container,BdbTime::minusInfinity) ) {
      cerr << "failed to set baseline iterator" << endl;
      break;
    }

    BdbHandle(BdbIntervalR) basenodeH;
    RWCString rack("[0");
    long nodes = 0;
    long maxnodes = 0;
    long intervals = 0;
    long maxheight = 0;
    long avgheight = 0;
    long maxwidth = 0;
    long avgwidth = 0;
    while ( itr.next() ) {

      basenodeH = (BdbHandle(BdbIntervalR)&) itr;
      if ( ! nodes ) DBGL( "the first interval is: [" << translateOID(basenodeH) << "]" );

      long currentheight = 0;
      long currentwidth = 1;
      long currentnodes = 0;
      if ( CMD_SUCCESS != analyzeNode(basenodeH, rack, currentnodes, 
                                      currentheight, currentwidth,
                                      maxheight, avgheight ) ) break;
      if ( currentwidth > maxwidth ) {
        maxwidth = currentwidth;
      }
      avgwidth += currentwidth;
      nodes += currentnodes;
      if ( currentnodes > maxnodes ) maxnodes = currentnodes;
      ++intervals;

    }

    status = CMD_SUCCESS;

    if ( intervals > 0 ) {
      avgwidth /= intervals;
      avgheight /= intervals;
    }

    OUTL("baseints", intervals);
    OUTL("nodes   ", nodes    );
    OUTL("maxnodes", maxnodes );
    OUTL("maxh    ", maxheight);
    OUTL("maxw    ", maxwidth );
    OUTL("avgh    ", avgheight);
    OUTL("avgw    ", avgwidth );

  } while ( 0 );

  usecs = (clock() - usecs)/1000;
  msecs = getMillis() - msecs;
  OUTL("tasystem", usecs);
  OUTL("taastro ", msecs );
  return status;
}





//=====================================
//      store a vector of objects
//=====================================
result cmd_storevectorn(const RWCString& detector, const RWCString& container,
                        int elts, const RWCString& object,
                        const BdbTime& starttime, const BdbTime& offsettime ) {
  std::vector<BdbCondStoreTime> objvector;
  BdbHandle(BdbObject) objH;

  int idx = 0;
  long d = offsettime.getGmtSec() - starttime.getGmtSec();
  DBG("-> storevectorn " << elts << " of " << object << " at " << starttime.getGmtSec() << " " << d);

  result status = CMD_SUCCESS;
  while ( CMD_SUCCESS == status && idx < elts ) {
    if ( 0 == idx && object == "-" ) {
      status = makeObject( detector, "a", objH );
    } else {
      status = makeObject( detector, object, objH );
    }
    if ( CMD_SUCCESS == status ) {
      objvector.push_back( BdbCondStoreTime(starttime + (long)d*idx, objH) );
    }
    ++idx;
  }
  if ( CMD_SUCCESS == status ) {
    status = makeObject( detector, "-", objH );
    objvector.push_back( BdbCondStoreTime(starttime + d*elts, objH) );

    BdbObsoleteDatabase db( detector );
    if ( BdbcSuccess != db.storeVector( objvector, container ) ) {
      cerr << "failed to storevectorn" << endl;
      status = CMD_ERROR;
    }
  }

  DBGRES( status );
  return status;
}




//=====================================
//      store a vector of objects
//=====================================
result cmd_storevector(const RWCString& detector, const RWCString& container,
                       int elts,
                       RWTValOrderedVector<RWCString>& strings,
                       RWTValOrderedVector<BdbTime>& times ) {
  std::vector<BdbCondStoreTime> objvector;

  BdbHandle(BdbObject) objH;
  DBG( "-> storevector of " << elts );

  int idx = 0;
  result status;
  while ( idx < elts ) {
    if ( 0 == idx && "-" == strings(idx) ) {
      status = makeObject( detector, "a", objH );
    } else {
      status = makeObject( detector, strings(idx), objH );
    }
    if ( CMD_SUCCESS != status ) break;
    objvector.push_back( BdbCondStoreTime(times(idx),objH) );
    ++idx;
  }

  if ( CMD_SUCCESS == status ) {

    // terminator
    status = makeObject( detector, "-", objH );
    objvector.push_back( BdbCondStoreTime(times(idx),objH) );

    BdbObsoleteDatabase db( detector );
    if ( BdbcSuccess != db.storeVector( objvector, container ) ) {
      cerr << "failed to store vector" << endl;
      status = CMD_ERROR;
    }

  }

  DBGRES( status );
  return status;
}

 

---

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

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