Athena::RootSvc Class Reference

This class provides the interface to the ROOT software. More...

#include <RootSvc.h>

Inheritance diagram for Athena::RootSvc:

Collaboration diagram for Athena::RootSvc:

Public Member Functions
	RootSvc (const std::string &name, ISvcLocator *pSvcLocator)
	Standard Service Constructor.
StatusCode	initialize ()
	Gaudi Service Interface method implementations:
StatusCode	finalize ()
StatusCode	open (const std::string &fname, const std::string &mode)
	Open the file fname with open mode mode
StatusCode	connect (const std::string &fname)
	Connect the file fname to the service.
StatusCode	commitOutput ()
	Commit data and flush buffer.
StatusCode	disconnect (const std::string &fname)
	Disconnect the file fname from the service.
Athena::RootConnection *	connection (const std::string &fname)
	Get the RootConnection associated with file fname
virtual	~RootSvc ()
	Destructor.
RootType	getType (const std::type_info &type) const
	Load the type (dictionary) from Root.
void *	readObject (const Token &token, void *&pObj)
	Read object from Root.
const Token *	writeObject (const Placement &placement, const RootType &type, const void *pObj)
	Write object of a given class to Root.
void *	createObject (const RootType &type) const
	Create an object of a given RootType.
void	destructObject (const RootType &type, void *pObj) const
	Destruct a given object of type RootType.

Private Types
typedef std::map< Guid, Athena::RootConnection * >	ConnMap_t

Private Member Functions
	RootSvc ()
	Default constructor:
	RootSvc (const RootSvc &)
RootSvc &	operator= (const RootSvc &)

Private Attributes
pool::IFileCatalog *	m_catalog
ConnMap_t	m_conns
	Map of file name keys and connection values.
Athena::RootConnection *	m_wconn
ServiceHandle< ::IDictLoaderSvc >	m_dictSvc
	ServiceHandle to the dictionary service.

Detailed Description

This class provides the interface to the ROOT software.

Definition at line 39 of file RootSvc.h.

Member Typedef Documentation

ConnMap_t

typedef std::map<Guid, Athena::RootConnection*> Athena::RootSvc::ConnMap_t

private

Definition at line 94 of file RootSvc.h.

Constructor & Destructor Documentation

RootSvc() [1/3]

Athena::RootSvc::RootSvc	(	const std::string &	name,
		ISvcLocator *	pSvcLocator )

Standard Service Constructor.

Definition at line 27 of file RootSvc.cxx.

                                                                :
    base_class(name, pSvcLocator),
    m_catalog(0),
    m_conns(),
    m_wconn(0),
    m_dictSvc("AthDictLoaderSvc", name) {
}

~RootSvc()

Athena::RootSvc::~RootSvc ( )

virtual

Destructor.

Definition at line 35 of file RootSvc.cxx.

                  {
  for (ConnMap_t::iterator itr = m_conns.begin(), iend = m_conns.end(); itr != iend; ++itr) {
    delete itr->second; itr->second = 0;
  }
  m_conns.clear();
}

RootSvc() [2/3]

Athena::RootSvc::RootSvc ( )

private

Default constructor:

RootSvc() [3/3]

Athena::RootSvc::RootSvc ( const RootSvc & )

private

Member Function Documentation

commitOutput()

StatusCode Athena::RootSvc::commitOutput

(

)

Commit data and flush buffer.

Definition at line 155 of file RootSvc.cxx.

                                 {
  ATH_MSG_VERBOSE("RootSvc::commitOutput");
  if (m_wconn == 0) {
    ATH_MSG_ERROR("Cannot commit without RootConnection.");
    return StatusCode::FAILURE;
  }
  if (!m_wconn->commit().isSuccess()) {
    ATH_MSG_ERROR("Cannot commit RootConnection.");
    return StatusCode::FAILURE;
  }
  return StatusCode::SUCCESS;
}

connect()

StatusCode Athena::RootSvc::connect

(

const std::string &

fname

)

Connect the file fname to the service.

Definition at line 140 of file RootSvc.cxx.

                                                  {
  ATH_MSG_VERBOSE("connect(" << fname << ")...");
  Athena::RootConnection* conn = this->connection(fname);
  if (conn == 0) {
    ATH_MSG_ERROR("No open RootConnection for file " << fname);
    return StatusCode::FAILURE;
  }
  if (!conn->connectWrite("recreate").isSuccess()) {
    ATH_MSG_ERROR("Cannot connect to file " << fname);
    return StatusCode::FAILURE;
  }
  m_wconn = conn;
  return StatusCode::SUCCESS;
}

connection()

Athena::RootConnection * Athena::RootSvc::connection

(

const std::string &

fname

)

Get the RootConnection associated with file fname

Returns

NULL if no such file is known to this service

Definition at line 188 of file RootSvc.cxx.

                                                                {
// Catalog to get fid...
  Guid fid = Guid::null();
  if (m_catalog != 0) {
     std::string fidString, ftype;
     m_catalog->lookupFileByPFN(fname, fidString, ftype);
     if( fidString.empty() ) {
        m_catalog->registerPFN(fname, "ROOT_All", fidString);
     }
     fid.fromString(fidString);
  }
  Athena::RootConnection* conn = 0;
  ConnMap_t::const_iterator fitr = m_conns.find(fid);
  if (fitr != m_conns.end()) {
    conn = fitr->second;
  }
  return conn;
}

createObject()

void * Athena::RootSvc::createObject

(

const RootType &

type

)

const

Create an object of a given RootType.

Definition at line 103 of file RootSvc.cxx.

                                                      {
  void* pObj = type.Construct();
  return pObj;
}

destructObject()

void Athena::RootSvc::destructObject	(	const RootType &	type,
		void *	pObj ) const

Destruct a given object of type RootType.

Definition at line 109 of file RootSvc.cxx.

                                                             {
}

disconnect()

StatusCode Athena::RootSvc::disconnect

(

const std::string &

fname

)

Disconnect the file fname from the service.

Definition at line 169 of file RootSvc.cxx.

                                                     {
  ATH_MSG_VERBOSE("disconnect(" << fname << ")...");
  Athena::RootConnection* conn = this->connection(fname);
  if (conn == 0) {
    ATH_MSG_ERROR("No open RootConnection for file " << fname);
    return StatusCode::FAILURE;
  }
  if (!conn->disconnect().isSuccess()) {
    ATH_MSG_ERROR("Cannot disconnect to file " << fname);
    return StatusCode::FAILURE;
  }
  if (m_wconn == conn) {
    m_wconn = 0;
  }
  return StatusCode::SUCCESS;
}

finalize()

StatusCode Athena::RootSvc::finalize

(

)

Definition at line 60 of file RootSvc.cxx.

                             {
  for (ConnMap_t::const_iterator itr = m_conns.begin(), iend = m_conns.end(); itr != iend; ++itr) {
    if (!itr->second->disconnect().isSuccess()) {
      ATH_MSG_WARNING("Cannot disconnect file = " << itr->first.toString());
    }
  }
  if (m_catalog != 0) {
    m_catalog->commit();
    delete m_catalog; m_catalog = 0;
  }
  return ::AthService::finalize();
}

getType()

RootType Athena::RootSvc::getType

(

const std::type_info &

type

)

const

Load the type (dictionary) from Root.

RootType-base interface Load the type (dictionary) from Root.

Definition at line 74 of file RootSvc.cxx.

                                                        {
  return m_dictSvc->load_type(type);
}

initialize()

StatusCode Athena::RootSvc::initialize

(

)

Gaudi Service Interface method implementations:

Definition at line 42 of file RootSvc.cxx.

                               {
  ATH_MSG_INFO("Initializing " << name());
  if (!::AthService::initialize().isSuccess()) {
    ATH_MSG_FATAL("Cannot initialize ConversionSvc base class.");
    return StatusCode::FAILURE;
  }
  m_catalog = new pool::IFileCatalog;
  try {
    m_catalog->setWriteCatalog("xmlcatalog_file:RootFileCatalog.xml"); // FIXME: Make config
    m_catalog->start();
  } catch (std::exception& e) {
    ATH_MSG_FATAL ("Set up Catalog - caught exception: " << e.what());
    return StatusCode::FAILURE;
  }
  ATH_CHECK(m_dictSvc.retrieve());
  return StatusCode::SUCCESS;
}

open()

StatusCode Athena::RootSvc::open	(	const std::string &	fname,
		const std::string &	mode )

Open the file fname with open mode mode

Definition at line 113 of file RootSvc.cxx.

                                                                   {
// Catalog to get fid...
  Guid fid = Guid::null();
  if (m_catalog != 0) {
    std::string fidString, ftype;
    m_catalog->lookupFileByPFN(fname, fidString, ftype);
    if( fidString.empty() ) {
       m_catalog->registerPFN(fname, "ROOT_All", fidString);
    }
    fid.fromString(fidString);
  }
  Athena::RootConnection* conn = 0;
  ConnMap_t::const_iterator fitr = m_conns.find(fid);
  if (fitr == m_conns.end()) {
    conn = new Athena::RootConnection(this, fname);
    m_conns.insert(std::make_pair(fid, conn));
  } else {
    conn = fitr->second;
  }
  if (conn == 0) {
    ATH_MSG_ERROR("Cannot get RootConnection for file " << fid.toString());
    return StatusCode::FAILURE;
  }
  return StatusCode::SUCCESS;
}

operator=()

RootSvc & Athena::RootSvc::operator= ( const RootSvc & )

private

readObject()

void * Athena::RootSvc::readObject	(	const Token &	token,
		void *&	pObj )

Read object from Root.

Definition at line 79 of file RootSvc.cxx.

                                                  {
  return 0;
}

writeObject()

const Token * Athena::RootSvc::writeObject	(	const Placement &	placement,
		const RootType &	type,
		const void *	pObj )

Write object of a given class to Root.

Definition at line 84 of file RootSvc.cxx.

                                                                                                    {
  ATH_MSG_VERBOSE("RootSvc::writeObject pObj = " << pObj);
  if (m_wconn == 0) {
    ATH_MSG_ERROR("Cannot write without RootConnection for placement " << placement.containerName());
    return 0;
  }
  if (!m_wconn->setContainer(placement.containerName(), type.Name()).isSuccess()) {
    ATH_MSG_ERROR("Cannot set container [" << placement.containerName() << "]");
    return 0;
  }
  unsigned long ientry = 0;
  if (!m_wconn->write(pObj, ientry).isSuccess()) {
    ATH_MSG_ERROR("Cannot write Object to placement [" << placement.containerName() << "]");
    return 0;
  }
  return new Token();
}

Member Data Documentation

m_catalog

pool::IFileCatalog* Athena::RootSvc::m_catalog

private

Definition at line 92 of file RootSvc.h.

m_conns

ConnMap_t Athena::RootSvc::m_conns

private

Map of file name keys and connection values.

Definition at line 96 of file RootSvc.h.

m_dictSvc

ServiceHandle< ::IDictLoaderSvc> Athena::RootSvc::m_dictSvc

private

ServiceHandle to the dictionary service.

Definition at line 100 of file RootSvc.h.

m_wconn

Athena::RootConnection* Athena::RootSvc::m_wconn

private

Definition at line 97 of file RootSvc.h.

---

The documentation for this class was generated from the following files:

• RootSvc.h
• RootSvc.cxx