In This Package:

MockEvtSelector.cpp

Go to the documentation of this file.

#include "MockEvtSelector.h"

#include "MockEvtStructure.h"

#include "GaudiKernel/GaudiException.h"
#include "GaudiKernel/MsgStream.h"

using namespace MockEvtConverters;

MockEvtSelector::MockEvtSelector(const std::string& name,
                                 ISvcLocator* svc) :
                                   Service(name,
                                           svc) {
  declareProperty("ReadoutPath",
                  m_readoutPath="/Event/MockEvt/Readout");
}

StatusCode MockEvtSelector::createContext(Context*& context) const {

  context = new MockEvtContext();

  return StatusCode::SUCCESS;
}

StatusCode MockEvtSelector::releaseContext(Context*& context) const {

  if (0 != context) {
    delete context;
  }

  return StatusCode::SUCCESS;
}

StatusCode MockEvtSelector::next(Context& context) const {
  return next(context,
              1);
}

StatusCode MockEvtSelector::next(Context& context,
                                 int jump) const {
  MockEvtContext *ctxt = dynamic_cast<MockEvtContext*>(&context);
  ctxt->jump(jump);

  return StatusCode::SUCCESS;
}

StatusCode MockEvtSelector::createAddress(const Context& context,
                                          IOpaqueAddress*& addr) const {

  const MockEvtContext *ctxt = dynamic_cast<const MockEvtContext*>(&context);
  StatusCode status = ctxt->getEvent();
  if (status.isFailure()) {
    return StatusCode::FAILURE;
  }

  addr = new MockEvtStructure::Address(ctxt);

  return StatusCode::SUCCESS;
}

StatusCode MockEvtSelector::queryInterface(const InterfaceID& id,
                                           void** interface) {
  if (IEvtSelector::interfaceID().versionMatch(id)) {
    // If good enough match return this object.
    *interface = (IEvtSelector*)this;
    addRef();
  } else {
    // Interface is not directly available: try out a base class.
    return Service::queryInterface(id,
                                   interface);
  }

  return StatusCode::SUCCESS;
}

MockEvtSelector::~MockEvtSelector() {
}

StatusCode MockEvtSelector::previous(Context&) const {
  return StatusCode::FAILURE;
}

StatusCode MockEvtSelector::previous(Context&,
                                     int) const {
  return StatusCode::FAILURE;
}

StatusCode MockEvtSelector::last(Context&) const {
  return StatusCode::FAILURE;
}

StatusCode MockEvtSelector::rewind(Context&) const {
  return StatusCode::FAILURE;
}

StatusCode MockEvtSelector::resetCriteria(const std::string&,
                                          Context&) const {
  return StatusCode::FAILURE;
}


MockEvtSelector::MockEvtContext::MockEvtContext() :
  m_sequenceNumber(0),
  m_readoutTime(time(0),
                0) {
}

MockEvtSelector::MockEvtContext::~MockEvtContext() {
}

void MockEvtSelector::MockEvtContext::jump(int distance) {
  m_sequenceNumber += distance;
  m_readoutTime.Add(distance * 0.0000001 * (random() % 1000));
}

StatusCode MockEvtSelector::MockEvtContext::getEvent() const {
  return StatusCode::SUCCESS;
}

const TimeStamp& MockEvtSelector::MockEvtContext::readoutTime() const {
  return m_readoutTime;
}

int MockEvtSelector::MockEvtContext::sequenceNumber() const {
  return m_sequenceNumber;
}

---