---

JobOptionsSvc.cpp

Go to the documentation of this file.

// JobOptionsSvc.cpp: implementation of the JobOptionsSvc class.
//

#include "GaudiKernel/SvcFactory.h"
#include "GaudiKernel/MsgStream.h"
#include "JobOptionsSvc.h"
#include "PropertyCompiler.h"
#include "JobOptionsCatalogue.h"
#include "JobOptionsList.h"

// Instantiation of a static factory class used by clients to create
// instances of this service
static SvcFactory<JobOptionsSvc> s_factory;
const ISvcFactory& JobOptionsSvcFactory = s_factory;

// Constructor

JobOptionsSvc::JobOptionsSvc(const std::string& name,ISvcLocator* svc) : Service(name,svc) {
        m_pmgr.declareProperty( std::string("TYPE"), m_source_type );
        m_pmgr.declareProperty( std::string("PATH"), m_source_path );
        m_source_type = "FILE";
        if ( 0 == getenv("JOB_OPTIONS") ) {
          m_source_path = "jobOptions.txt"; // Default options file in execution directory
        }
        else {
          m_source_path = getenv("JOB_OPTIONS");
        }
}


// Delegate IProperty implementation to PropertyMgr
StatusCode JobOptionsSvc::setProperty( const Property &p ) {
        return m_pmgr.setProperty( p );
}

StatusCode JobOptionsSvc::getProperty( Property *p ) const {
        return m_pmgr.getProperty( p );
}

// IJobOptions implementation

StatusCode JobOptionsSvc::setMyProperties( const std::string& client,
                                                                                   IProperty* myInt ) {
    std::vector<const Property*>* myList;
    StatusCode sc;

// Get the list of options for this client
        sc = m_catalogue.optionsOf( client, myList );
        if( !sc.isSuccess() ) return StatusCode::SUCCESS;  // Algorithm has no options

// Iterate over the list to set the options
        for( std::vector<const Property*>::iterator iter = myList->begin(); iter != myList->end(); iter++ )   {
    const StringProperty* sp = dynamic_cast<const StringProperty*>(*iter);
    sc = StatusCode::FAILURE;
    if ( 0 != sp )    {
                sc = myInt->setProperty( (*iter)->name(), sp->value() );
    }
    else  {
      const StringArrayProperty* sap = dynamic_cast<const StringArrayProperty*>(*iter);
      if ( 0 != sap )   {
        std::string prop = "[";
        const std::vector<std::string>& vals = sap->value();
        for ( unsigned int i = 0; i < vals.size(); i++ )   {
          prop += vals[i];
          if ( i+1 < vals.size() ) prop += ", ";
        }
        prop += "] ";
        sc = myInt->setProperty( (*iter)->name(), prop );
      }
    }
                if( !sc.isSuccess() ) {
                        MsgStream my_log( this->msgSvc(), this->name() );
                        my_log << MSG::ERROR << "Unable to set property " << (*iter)->name() 
                                   << " of " << client 
                                   << "\nCheck option and algorithm names, type and bounds" << endreq;
                }
        }
        return sc;
}

// IService implementation and initialisation

StatusCode JobOptionsSvc::initialize() {
    // Call base class initializer
        StatusCode sc = Service::initialize();
        if( !sc.isSuccess() ) return sc;
        // Read the job options
        sc = this->readOptions();
        return sc;
}

// IInterface implementation
StatusCode JobOptionsSvc::queryInterface(const IID& riid, void** ppvInterface) {
  if ( IID_IJobOptionsSvc == riid )  {
    *ppvInterface = (IJobOptionsSvc*) this;
  }
  else if ( IID_IProperty == riid ) {
    *ppvInterface = (IProperty*) this;
  }
  else  {
    return Service::queryInterface(riid, ppvInterface);
  }
  addRef();
  return StatusCode::SUCCESS;
}

// Private member functions 

StatusCode JobOptionsSvc::readOptions() {
        StatusCode sc;
        MsgStream my_log( this->msgSvc(), this->name() );
        if ( this->source_type() == "NONE" ) {
                sc = StatusCode::SUCCESS;
        }
        else if( this->source_type() == "FILE" ) {
                PropertyCompiler jR( this->source_path(), my_log, m_catalogue );
                sc = jR.startCompiler();
        }
        else {
                sc = StatusCode::FAILURE;
                my_log << MSG::ERROR << "Unknown Job Options file type: " 
                           << this->source_type() << endreq;
        }

        if( sc.isSuccess() ) {
    // Now we have to resolve still all the entries which are references to other
    // Properties
    sc = m_catalogue.resolveOptions(my_log);
    if ( sc.isSuccess() )     {
                my_log << MSG::INFO << "Job options successfully read in from " 
                       << this->source_path() << endreq; 
    }
    else    {
                my_log << MSG::FATAL << "Job options references cannot be resolved." << endreq;
      m_catalogue.printUnresolvedOptions(my_log);
    }
        }
        else {
                my_log << MSG::FATAL << "Failed to read in job options" << endreq;
        }
        return sc;
}


std::string JobOptionsSvc::source_path() const {
        return m_source_path;
}

std::string JobOptionsSvc::source_type() const {
        return m_source_type;
}

---