JobCInput.cxx

Go to the documentation of this file.

// $Id: JobCInput.cxx,v 1.18 2009/01/05 06:10:20 schubert Exp $
//
// A module used for getting data into and emtpy data record. This
// module is implemented in terms of any of a variety of
// user/framework provided inputs modules
//
// This is essentially a wrapper class. Its methods just push off the
// call down the to the object which actually implements the input
// module
// 
// messier@huhepl.harvard.edu
#include "JobControl/JobCInput.h"
#include "MessageService/MsgService.h"
#include "JobControl/JobCModuleRegistry.h"
CVSID("$Id: JobCInput.cxx,v 1.18 2009/01/05 06:10:20 schubert Exp $");

ClassImp(JobCInput)

// static const JobCResult gsW = JobCResult::kWarning;

JobCInput::JobCInput() : fImpl(0) { }

//......................................................................

JobCInput::~JobCInput() 
{ 
  if (fImpl) { 
    fImpl->EndJob();
    delete fImpl; fImpl = 0; 
  }
}

//...................................................................... 

JobCResult JobCInput::Get()
{ 
  if (this->CheckImpl()) {
    JobCResult r = fImpl->Get();
#ifdef SITE_HAS_SIGC
    this->SigGet();
#endif
    return r;
  }
  return JobCResult::kEndOfInputStream;
}

//...................................................................... 

JobCResult JobCInput::Next(int n)
{
  if (this->CheckImpl()) {
    JobCResult r = fImpl->Next(n); 
#ifdef SITE_HAS_SIGC
    this->SigNext();
#endif
    return r;
  }
  return JobCResult::kError;
}

//...................................................................... 

JobCResult JobCInput::Prev(int n) 
{
  if (this->CheckImpl()){
    JobCResult r = fImpl->Prev(n); 
#ifdef SITE_HAS_SIGC
    this->SigPrev();
#endif
    return r;
  }
  return JobCResult::kError;
}

//...................................................................... 

JobCResult JobCInput::GoTo(int r, int s, int d) 
{
  if (this->CheckImpl()) {
    JobCResult re = fImpl->GoTo(r,s,d); 
#ifdef SITE_HAS_SIGC
    this->SigGoTo();
#endif
    return re;
  }
  return JobCResult::kError;
}


//...................................................................... 

Int_t JobCInput::GetCurrentRun() const
{
 if (this->CheckImpl()) 
   return fImpl->GetCurrentRun();
 return -1;
}

//...................................................................... 

Int_t JobCInput::GetLastRun() const
{
 if (this->CheckImpl()) 
   return fImpl->GetLastRun();
 return -1;
}

//...................................................................... 

const char* JobCInput::GetCurrentFile(const char* streamname) const
{
    if (this->CheckImpl()) 
        return fImpl->GetCurrentFile(streamname);
    return 0;
}

//...................................................................... 

const char* JobCInput::GetLastFile(const char* streamname) const
{
    if (this->CheckImpl()) 
        return fImpl->GetLastFile(streamname);
    return 0;
}

//...................................................................... 

Int_t JobCInput::GetCurrentSnarl() const
{
 if (this->CheckImpl()) 
   return fImpl->GetCurrentSnarl();
 return -1;
}

//...................................................................... 

JobCResult JobCInput::GoTo(const VldContext& vld)
{
  if (this->CheckImpl()) {
    JobCResult r = fImpl->GoTo(vld);
#ifdef SITE_HAS_SIGC
    this->SigGoTo();
#endif
    return r;
  }
  return JobCResult::kError;
}

//...................................................................... 

void JobCInput::List(const char* streamlist) const 
{
  if (this->CheckImpl()) fImpl->List(streamlist);
}

//...................................................................... 

void JobCInput::AddFile(const char* filename, const char* streamlist, int at) 
{
  if (this->CheckImpl()) fImpl->AddFile(filename,streamlist,at);
}

//...................................................................... 

void JobCInput::RemoveFile(const char* filename, const char* streamlist) 
{
  if (this->CheckImpl()) fImpl->RemoveFile(filename,streamlist);
}

//...................................................................... 

void JobCInput::Select(const char* stream, const char* cut, bool isrequired) 
{
  if (this->CheckImpl()) fImpl->Select(stream,cut,isrequired);
}

//...................................................................... 

void JobCInput::SetSequenceMode(const char* stream,Per::ESequenceMode seqmode) 
{
  if (this->CheckImpl()) fImpl->SetSequenceMode(stream,seqmode);
}

//...................................................................... 

void JobCInput::SetPerOwnedDisabled(const char* stream,bool perowneddisabled) 
{
  if (this->CheckImpl()) fImpl->SetPerOwnedDisabled(stream,perowneddisabled);
}

//...................................................................... 

void JobCInput::SetTestMode(const char* stream,bool testmode) 
{
  if (this->CheckImpl()) fImpl->SetTestMode(stream,testmode);
}

//...................................................................... 

void JobCInput::SetWindow(const char* stream, double lower, double upper) 
{
  if (this->CheckImpl()) fImpl->SetWindow(stream,lower,upper);
}

//...................................................................... 

void JobCInput::SetMaxFileRepeat(const char* stream, int numRepeat)
{
  if (this->CheckImpl()) fImpl->SetMaxFileRepeat(stream,numRepeat);
}

//...................................................................... 

void JobCInput::SetMeanMom(const char* stream, double mean)
{
  if (this->CheckImpl()) fImpl->SetMeanMom(stream,mean);
}

//...................................................................... 

void JobCInput::SetPushRandom(const char* stream, bool setRandom)
{
  if (this->CheckImpl()) fImpl->SetPushRandom(stream,setRandom);
}

//...................................................................... 

void JobCInput::SetRandomSeed(int rSeed)
{
  if (this->CheckImpl()) fImpl->SetRandomSeed(rSeed);
}

//...................................................................... 

void JobCInput::DefineStream(const char* stream, const char* tree) 
{
  if (this->CheckImpl()) fImpl->DefineStream(stream,tree);
}

//...................................................................... 
  
JobCResult JobCInput::NextFile(int n, const char* streamlist) 
{
  if (this->CheckImpl()) return fImpl->NextFile(n,streamlist);
  return JobCResult::kError;
}

//...................................................................... 

JobCResult JobCInput::PrevFile(int n, const char* streamlist) 
{
  if (this->CheckImpl()) return fImpl->PrevFile(n, streamlist);
  return JobCResult::kError;
}

//...................................................................... 

JobCResult JobCInput::GoToFile(int i, const char* streamlist) 
{
  if (this->CheckImpl())  return fImpl->GoToFile(i, streamlist);
  return JobCResult::kError;
}

//...................................................................... 

JobCResult JobCInput::GoToFile(const char* filename, const char* streamlist) 
{
  if (this->CheckImpl()) return fImpl->GoToFile(filename, streamlist);
  return JobCResult::kError;
}

//...................................................................... 

void JobCInput::Use(const char* name) 
{
//======================================================================
// Set the input module to implement this class
//======================================================================

  // Use the name to lookup the proxy
  JobCModuleProxy* jmp = JobCModuleRegistry::Instance().LookUp(name);
  if (jmp==0) {
    MSG("JobC",Msg::kWarning) <<
      "No module '"<< name <<"' has been linked in." << std::endl;
    return;
  }

  // Use the proxy to instantiate a module
  JobCModule* m = jmp->CreateModule();
  if (m==0) {
    MSG("JobC",Msg::kWarning) <<
      "CreateModule(" << jmp->GetName() << ")" << std::endl;
    return;
  }

  // Try to cast the module as an input module
  JobCInputModule* inmod = dynamic_cast<JobCInputModule*>(m);
  if (inmod==0) {
    MSG("JobC",Msg::kError) << 
      "Module '" << jmp->GetName() << 
      "' cannot be used as an input module." << std::endl;
    delete m; m = 0;
    return;
  }

  // Switch to the new implementation
  if (fImpl) { 
    fImpl->EndJob();
    delete fImpl; fImpl = 0; 
  }
  fImpl = inmod;

  // Set up the new module
  assert(this->GetMom());
  fImpl->SetMom(this->GetMom());
  fImpl->BeginJob();
}

//......................................................................   

const Registry& JobCInput::DefaultConfig() const
{
  MSG("JobC",Msg::kDebug) << "JobCInput::DefaultConfig()\n";

  if (this->CheckImpl()) return fImpl->DefaultConfig();

  MSG("JobC",Msg::kDebug) << "Using dummy config!\n";
  static Registry r; // A dummy config...
  return r;
}

//......................................................................   

Registry& JobCInput::GetConfig()
{
//======================================================================
// To make the JobCInput fit transparently over the module that
// actually implements the input module we don't ever want to talk to
// JobCInput::fConfig we want to talk to fImpl->fConfig. JobCModule
// has been written very carefully to never reference fConfig directly
// but only through this method...
//======================================================================
  if (this->CheckImpl()) return fImpl->GetConfig();
  
  MSG("JobC",Msg::kDebug) << "Returning dummy config!\n";
  static Registry r; // A dummy config...
  return r;
}


//......................................................................   

// Save a little typing. This macro works for void m(void)
#define IMP(m) { if (this->CheckImpl()) fImpl->m(); }
void JobCInput::BeginJob()  { IMP(BeginJob)  }
void JobCInput::EndJob()    { IMP(EndJob)    }
void JobCInput::BeginFile() { IMP(BeginFile) }
void JobCInput::EndFile()   { IMP(EndFile)   }
void JobCInput::BeginRun()  { IMP(BeginRun)  }
void JobCInput::EndRun()    { IMP(EndRun)    }
void JobCInput::Help()      { IMP(Help)      }
void JobCInput::Report()    { IMP(Report)    }
void JobCInput::Reset()     { IMP(Reset)     }
#undef IMP

//......................................................................   

// Save a litte typing. This macro works for void m(a)
#define IMP(m,a) { if (this->CheckImpl()) fImpl->m(a); }
void JobCInput::Config(const Registry& r)   { IMP(Config,r) }
void JobCInput::Cmd(const char* c)          { IMP(Cmd,c)    }
void JobCInput::HandleCommand(JobCommand *c){ IMP(HandleCommand,c) }
#undef IMP
// JobCResult JobCInput::Get(MomNavigator *m)       { return gsW; }
// JobCResult JobCInput::Put(const MomNavigator *m) { return gsW; }

//......................................................................   

int JobCInput::CheckImpl() const
{
//======================================================================
// Check if we have a valid pointer to an input module
//======================================================================
  if (fImpl==0) {
    MSG("JobC",Msg::kWarning) <<
      "No implementation provided for Input module. Try this:"
      " Input.Use(\"Input\")" << std::endl;
    return 0;
  }
  return 1;
}

---