AuxDiscoverySvc Class Reference

This class provides the interface between AthenaPoolCnvSvc and AuxStore classes. More...

#include <AuxDiscoverySvc.h>

Collaboration diagram for AuxDiscoverySvc:

Public Member Functions
	AuxDiscoverySvc ()
bool	getAuxStore (void *obj, const Guid &classId, const std::string &contId)
bool	setData (SG::auxid_t auxid, void *data, const RootType &type)
bool	setAuxStore ()
SG::auxid_t	getAuxID (const std::string &attrName, const std::string &elemName, const std::string &typeName)
SG::auxid_set_t	getAuxIDs (const void *obj, const Guid &classId, const std::string &contId)
const void *	getData (SG::auxid_t auxid)
const std::type_info *	getType (SG::auxid_t auxid)
std::string	getAttrName (SG::auxid_t auxid)
std::string	getTypeName (SG::auxid_t auxid)
std::string	getElemName (SG::auxid_t auxid)
StatusCode	receiveStore (const IAthenaSerializeSvc *serSvc, IAthenaIPCTool *ipcTool, void *obj, int num=0)
	Receive dynamic aux store variables from streaming tool.
StatusCode	sendStore (const IAthenaSerializeSvc *serSvc, IAthenaIPCTool *ipcTool, const void *obj, const Guid &classId, const std::string &contName, int num=0)
	Send dynamic aux store variables to streaming tool.

Private Attributes
const SG::IAuxStoreIO *	m_store
AthenaPoolAuxStore *	m_storeInt
SG::IAuxStoreHolder *	m_storeHolder

Detailed Description

This class provides the interface between AthenaPoolCnvSvc and AuxStore classes.

Definition at line 33 of file AuxDiscoverySvc.h.

Constructor & Destructor Documentation

AuxDiscoverySvc()

AuxDiscoverySvc::AuxDiscoverySvc ( )

inline

Definition at line 35 of file AuxDiscoverySvc.h.

: m_store(0), m_storeInt(0), m_storeHolder(0) {}

Member Function Documentation

getAttrName()

std::string AuxDiscoverySvc::getAttrName

(

SG::auxid_t

auxid

)

Definition at line 151 of file AuxDiscoverySvc.cxx.

                                                      {
   return SG::AuxTypeRegistry::instance().getName(auxid);
}

getAuxID()

SG::auxid_t AuxDiscoverySvc::getAuxID	(	const std::string &	attrName,
		const std::string &	elemName,
		const std::string &	typeName )

Definition at line 93 of file AuxDiscoverySvc.cxx.

                                                                                                                   {
   SG::AuxTypeRegistry& registry = SG::AuxTypeRegistry::instance();
   SG::auxid_t auxid = registry.findAuxID(attrName);
   if (auxid == SG::null_auxid && m_storeInt != nullptr) {
      try {
         RootUtils::Type elemType(elemName);
         const std::type_info* eti = elemType.getTypeInfo();
         if (eti == nullptr) {
            return SG::null_auxid;
         }
         auxid = SG::getDynamicAuxID(*eti, attrName, elemName, typeName, m_storeInt->standalone(), SG::null_auxid);
      } catch (const std::runtime_error&) {
         return SG::null_auxid;
      }
   }
   return auxid;
}

getAuxIDs()

SG::auxid_set_t AuxDiscoverySvc::getAuxIDs	(	const void *	obj,
		const Guid &	classId,
		const std::string &	contId )

Definition at line 112 of file AuxDiscoverySvc.cxx.

                                                                                        {
   const pool::DbTypeInfo* info = pool::DbTypeInfo::create(classId); // Needed for Properties and TClass
   if (info == nullptr) {
      return SG::auxid_set_t();
   }
   if (!contId.empty() && (contId.size() < 5 || contId.substr(contId.size() - 5, 4) != "Aux.")
       && !info->clazz().Properties().HasProperty("IAuxStore")) {
      return SG::auxid_set_t();
   }
   // Detected auxStore
   TClass* cl = info->clazz().Class();
   if (cl == nullptr) {
      return SG::auxid_set_t();
   }
   TClass* storeTC = cl->GetBaseClass("SG::IAuxStoreIO");
   if (storeTC == nullptr) {
      return SG::auxid_set_t();
   }
   m_store = reinterpret_cast<const SG::IAuxStoreIO*>((const char*)obj + cl->GetBaseClassOffset(storeTC));
   if (m_store == nullptr) {
      return SG::auxid_set_t();
   }
   return m_store->getSelectedAuxIDs();
}

getAuxStore()

bool AuxDiscoverySvc::getAuxStore	(	void *	obj,
		const Guid &	classId,
		const std::string &	contId )

Definition at line 39 of file AuxDiscoverySvc.cxx.

                                                                                         {
   const pool::DbTypeInfo* info = pool::DbTypeInfo::create(classId); // Needed for Properties and TClass
   if (info == nullptr) {
      return false;
   }
   if (!contId.empty() && (contId.size() < 5 || contId.substr(contId.size() - 5, 4) != "Aux.")
       && !info->clazz().Properties().HasProperty("IAuxStore")) {
      return false;
   }
   TClass* cl = info->clazz().Class();
   if (cl == nullptr) {
      return false;
   }
   TClass* holderTC = cl->GetBaseClass("SG::IAuxStoreHolder");
   if (holderTC == nullptr) {
      return false;
   }
   m_storeHolder = reinterpret_cast<SG::IAuxStoreHolder*>((char*)obj + cl->GetBaseClassOffset(holderTC));
   if (m_storeHolder == nullptr) {
      return false;
   }
   bool standalone = m_storeHolder->getStoreType() == SG::IAuxStoreHolder::AST_ObjectStore;
   m_storeInt = new AthenaPoolAuxStore(standalone);
   return true;
}

getData()

const void * AuxDiscoverySvc::getData

(

SG::auxid_t

auxid

)

Definition at line 137 of file AuxDiscoverySvc.cxx.

                                                    {
   if (m_store == nullptr) {
      return nullptr;
   }
   return m_store->getIOData(auxid);
}

getElemName()

std::string AuxDiscoverySvc::getElemName

(

SG::auxid_t

auxid

)

Definition at line 159 of file AuxDiscoverySvc.cxx.

                                                      {
   return SG::AuxTypeRegistry::instance().getTypeName(auxid);
}

getType()

const std::type_info * AuxDiscoverySvc::getType

(

SG::auxid_t

auxid

)

Definition at line 144 of file AuxDiscoverySvc.cxx.

                                                            {
   if (m_store == nullptr) {
      return nullptr;
   }
   return m_store->getIOType(auxid);
}

getTypeName()

std::string AuxDiscoverySvc::getTypeName

(

SG::auxid_t

auxid

)

Definition at line 155 of file AuxDiscoverySvc.cxx.

                                                      {
   return SG::normalizedTypeinfoName(*(getType(auxid)));
}

receiveStore()

StatusCode AuxDiscoverySvc::receiveStore	(	const IAthenaSerializeSvc *	serSvc,
		IAthenaIPCTool *	ipcTool,
		void *	obj,
		int	num = 0 )

Receive dynamic aux store variables from streaming tool.

Definition at line 162 of file AuxDiscoverySvc.cxx.

                                                                                                                       {
   void* buffer = nullptr;
   size_t nbytes = 0;
   StatusCode sc = ipcTool->getObject(&buffer, nbytes, num);
   while (sc.isRecoverable() && nbytes > 0) {
      sc = ipcTool->getObject(&buffer, nbytes, num);
   }
   if (!sc.isSuccess() || nbytes == 0) { // No dynamic attributes
      return(StatusCode::SUCCESS);
   }
   Guid classId;
   classId.fromString(static_cast<const char*>(buffer));
   if (!ipcTool->getObject(&buffer, nbytes, num).isSuccess() || nbytes == 0) {
      return(StatusCode::FAILURE);
   }
   const std::string contName = std::string(static_cast<const char*>(buffer));
   if (classId != Guid::null() && this->getAuxStore(obj, classId, contName)) {
      void* nameData = nullptr;
      // StreamingTool owns buffer, will stay around until last dynamic attribute is copied
      while (ipcTool->getObject(&nameData, nbytes, num).isSuccess() && nbytes > 0) {
         const char* del1 = static_cast<const char*>(memchr(nameData, '\n', nbytes));
         const char* del2 = static_cast<const char*>(memchr(del1 + 1, '\n', nbytes - (del1 - static_cast<const char*>(nameData) - 1)));
         const std::string dataStr(static_cast<const char*>(nameData));
         const std::string& attrName = dataStr.substr(0, del1 - static_cast<const char*>(nameData));
         const std::string& typeName = dataStr.substr(del1 - static_cast<const char*>(nameData) + 1, del2 - del1 - 1);
         const std::string& elemName = dataStr.substr(del2 - static_cast<const char*>(nameData) + 1);
         if (ipcTool->getObject(&buffer, nbytes, num).isSuccess()) {
            SG::auxid_t auxid = this->getAuxID(attrName, elemName, typeName);
            if (auxid != SG::null_auxid) {
              const RootType type(typeName);
              void* dynAttr = nullptr;
              if (type.IsFundamental()) {
                dynAttr = new char[nbytes];
                std::memcpy(dynAttr, buffer, nbytes); buffer = nullptr;
              } else {
                dynAttr = serSvc->deserialize(buffer, nbytes, type); buffer = nullptr;
              }
              this->setData(auxid, dynAttr, type);
            }
         }
      }
      this->setAuxStore();
   }
   return(StatusCode::SUCCESS);
}

sendStore()

StatusCode AuxDiscoverySvc::sendStore	(	const IAthenaSerializeSvc *	serSvc,
		IAthenaIPCTool *	ipcTool,
		const void *	obj,
		const Guid &	classId,
		const std::string &	contName,
		int	num = 0 )

Send dynamic aux store variables to streaming tool.

Definition at line 208 of file AuxDiscoverySvc.cxx.

                 {
   const SG::auxid_set_t& auxIDs = this->getAuxIDs(obj, classId, contName);
   if (!auxIDs.empty()) {
      const std::string& classIdStr = classId.toString();
      if (!ipcTool->putObject(classIdStr.c_str(), classIdStr.size() + 1, num).isSuccess()) {
         return(StatusCode::FAILURE);
      }
      if (!ipcTool->putObject(contName.c_str(), contName.size() + 1, num).isSuccess()) {
         return(StatusCode::FAILURE);
      }
   }
   for (SG::auxid_t auxid : auxIDs) {
      const std::string& dataStr = this->getAttrName(auxid) + "\n" + this->getTypeName(auxid) + "\n" + this->getElemName(auxid);
      if (!ipcTool->putObject(dataStr.c_str(), dataStr.size() + 1, num).isSuccess()) {
         return(StatusCode::FAILURE);
      }
      const std::type_info* tip = this->getType(auxid);
      if (tip == nullptr) {
         return(StatusCode::FAILURE);
      }
      RootType type(*tip);
      StatusCode sc = StatusCode::FAILURE;
      if (type.IsFundamental()) {
         sc = ipcTool->putObject(this->getData(auxid), type.SizeOf(), num);
      } else {
         size_t nbytes = 0;
         void* buffer = serSvc->serialize(this->getData(auxid), type, nbytes);
         sc = ipcTool->putObject(buffer, nbytes, num);
         delete [] static_cast<char*>(buffer); buffer = nullptr;
      }
      if (!sc.isSuccess()) {
         return(StatusCode::FAILURE);
      }
   }
   return(StatusCode::SUCCESS);
}

setAuxStore()

bool AuxDiscoverySvc::setAuxStore

(

)

Definition at line 85 of file AuxDiscoverySvc.cxx.

                                  {
   if (m_storeHolder == nullptr) {
      return false;
   }
   m_storeHolder->setStore(m_storeInt);
   return true;
}

setData()

bool AuxDiscoverySvc::setData	(	SG::auxid_t	auxid,
		void *	data,
		const RootType &	type )

Definition at line 65 of file AuxDiscoverySvc.cxx.

                                                                               {
   SG::AuxTypeRegistry& registry = SG::AuxTypeRegistry::instance();
   if (m_storeInt->standalone()) {
      (void)m_storeInt->getData(auxid, 1, 1);
      registry.copy(auxid,
                    SG::AuxVectorInterface (*m_storeInt), 0,
                    SG::AuxVectorInterface (auxid, 1, const_cast<const void*>(data)), 0, 1);
      if (type.IsFundamental()) {
         delete [] (char*)data; data = nullptr;
      } else {
         type.Destruct(data); data = nullptr;
      }
   } else {
      // Move the data to the dynamic store.
      std::unique_ptr<SG::IAuxTypeVector> vec(registry.makeVectorFromData(auxid, data, nullptr, false, true));
      m_storeInt->addVector(std::move(vec), false);
   }
   return true;
}

Member Data Documentation

m_store

const SG::IAuxStoreIO* AuxDiscoverySvc::m_store

private

Definition at line 69 of file AuxDiscoverySvc.h.

m_storeHolder

SG::IAuxStoreHolder* AuxDiscoverySvc::m_storeHolder

private

Definition at line 71 of file AuxDiscoverySvc.h.

m_storeInt

AthenaPoolAuxStore* AuxDiscoverySvc::m_storeInt

private

Definition at line 70 of file AuxDiscoverySvc.h.

---

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

• AuxDiscoverySvc.h
• AuxDiscoverySvc.cxx