WhiteBoardSvc.cxx File Reference

#include <EventLoopAlgs/WhiteBoardSvc.h>
#include <memory>
#include <RootCoreUtils/Assert.h>
#include <EventLoop/IWorker.h>
#include <SampleHandler/MetaData.h>
#include <SampleHandler/MetaVector.h>

Include dependency graph for WhiteBoardSvc.cxx:

Go to the source code of this file.

Functions
	ClassImp (EL::WhiteBoardSvc) namespace EL

Function Documentation

ClassImp()

ClassImp

(

EL::WhiteBoardSvc

)

no invariant used

no invariant used

no invariant used

no invariant used

no invariant used

no invariant used

no invariant used

no invariant used

no invariant used

no invariant used

no invariant used

no invariant used

Definition at line 31 of file WhiteBoardSvc.cxx.

{
  WhiteBoardSvc *getWhiteBoardSvc (IWorker *worker)
  {
    RCU_REQUIRE_SOFT (worker != 0);
    WhiteBoardSvc *const result
      = dynamic_cast<WhiteBoardSvc*>(worker->getAlg ("WhiteBoardSvc"));
    RCU_ASSERT2_SOFT (result != 0, "whiteboard service not found");
    return result;
  }
 
 
 
  void WhiteBoardSvc ::
  testInvariant () const
  {
    RCU_INVARIANT (this != 0);
  }
 
 
 
  WhiteBoardSvc ::
  WhiteBoardSvc ()
  {
    RCU_NEW_INVARIANT (this);
  }
 
 
 
  bool WhiteBoardSvc ::
  hasVar (const std::string& name) const
  {
    return doHasVar (name);
  }
 
 
 
  float WhiteBoardSvc ::
  getFloat (const std::string& name) const
  {
    return doGetFloat (name);
  }
 
 
 
  void WhiteBoardSvc ::
  getArray (const std::string& name, std::size_t& size,
        const float*& values) const
  {
    std::size_t tmpSize = 0;
    const float *tmpValues = 0;
    doGetArray (name, tmpSize, tmpValues);
    size = tmpSize;
    values = tmpValues;
  }
 
 
 
  TObject *WhiteBoardSvc ::
  getTObject (const std::string& name) const
  {
    TObject *result = doGetTObject (name);
    RCU_PROVIDE (result != 0);
    return result;
  }
 
 
 
  void WhiteBoardSvc ::
  setFloat (const std::string& name, float value)
  {
    doSetFloat (name, value);
  }
 
 
 
  void WhiteBoardSvc ::
  setArray (const std::string& name, const std::vector<float>& value)
  {
    doSetArray (name, value.size(), &value[0]);
  }
 
 
 
  void WhiteBoardSvc ::
  setArray (const std::string& name, std::size_t size, const float *values)
  {
    doSetArray (name, size, values);
  }
 
 
 
  void WhiteBoardSvc ::
  setTObject (TObject *object, bool swallow)
  {
    doSetTObject (object, swallow);
  }
 
 
 
  const char *WhiteBoardSvc ::
  GetName () const
  {
    RCU_READ_INVARIANT (this);
    return "WhiteBoardSvc";
  }
 
 
 
  bool WhiteBoardSvc ::
  doHasVar (const std::string& /*name*/) const
  {
    RCU_ASSERT0_NOIMP ("failed to override WhiteBoardSvc::doHasVar");
    return false; // compiler dummy
  }
 
 
 
  float WhiteBoardSvc ::
  doGetFloat (const std::string& name) const
  {
 
    TObject *const object = getTObject (name);
    RCU_ASSERT (object != 0);
    SH::MetaData<float> *const meta
      = dynamic_cast<SH::MetaData<float>*>(object);
    RCU_ASSERT2_SOFT (meta != 0, ("variable " + name + " not of type float").c_str());
    return meta->value;
  }
 
 
 
  void WhiteBoardSvc ::
  doGetArray (const std::string& name, std::size_t& size,
          const float*& values) const
  {
 
    TObject *const object = getTObject (name);
    RCU_ASSERT (object != 0);
    SH::MetaVector<float> *const meta
      = dynamic_cast<SH::MetaVector<float>*>(object);
    RCU_ASSERT2_SOFT (meta != 0, ("variable " + name + " not of type float array").c_str());
    size = meta->value.size();
    values = &meta->value[0];
  }
 
 
 
  TObject *WhiteBoardSvc ::
  doGetTObject (const std::string& /*name*/) const
  {
    RCU_ASSERT0_NOIMP ("function WhiteBoardSvc::doGetTObject not overloaded");
    return 0; // compiler dummy
  }
 
 
 
  void WhiteBoardSvc ::
  doSetFloat (const std::string& name, float value)
  {
 
    std::unique_ptr<SH::MetaData<float> > meta (new SH::MetaData<float>);
    meta->SetName (name.c_str());
    meta->value = value;
    setTObject (meta.release(), true);
  }
 
 
 
  void WhiteBoardSvc ::
  doSetArray (const std::string& name, std::size_t size, const float *values)
  {
 
    std::unique_ptr<SH::MetaVector<float> > meta (new SH::MetaVector<float>);
    meta->SetName (name.c_str());
    std::vector<float> (values, values+size).swap (meta->value);
    setTObject (meta.release(), true);
  }
 
 
 
  void WhiteBoardSvc ::
  doSetTObject (TObject *object, bool swallow)
  {
    if (swallow)
      delete object;
    RCU_ASSERT0_NOIMP ("function WhiteBoardSvc::doSetTObject not overloaded");
  }
}