DataObjIDProperty.cpp

Go to the documentation of this file.

// stl includes
#include <sstream>
#include <map>
#include <boost/tokenizer.hpp>
#include <boost/algorithm/string.hpp>

// StoreGate includes
#include "GaudiKernel/DataObjIDProperty.h"

using namespace Gaudi;
using namespace Gaudi::Parsers;
using namespace Gaudi::Utils;

namespace Gaudi { 
  namespace Parsers {
     
    StatusCode 
    parse(DataObjID& v, const std::string& s) {
      // default values
      StatusCode sc(StatusCode::FAILURE);
      std::string prop;
      sc = Gaudi::Parsers::parse(prop, s);
            
      if (sc.isSuccess()) {
    //split the string in 1 or 2 words: 
    typedef boost::tokenizer<boost::char_separator<char> > tokenizer;
    boost::char_separator<char> sep("(), ");
    tokenizer tokens(prop, sep);
    int nToks(distance(tokens.begin(), tokens.end()));    
    auto it = tokens.begin();
    
    if (nToks == 1) {
      // Gaudi style /path/to/object
      std::string k = *it;
      boost::erase_all(k,"'");
      v = DataObjID( k );
      
    } else if (nToks == 2) {
      // ATLAS style (clid, 'key') or ('ClassName', 'key')
      CLID c(0);
      std::string cn(*it);
      DataObjID id;
      
      try {
        c = std::stoi(*it);
      } catch (const std::invalid_argument& /*e*/)  {
        // not a number
        boost::erase_all(cn,"'");
        c = 0;
      }
      
      ++it;
      std::string k = *it;
      boost::erase_all(k,"'");
      ++it;
      
      if ( c != 0) {
        v = DataObjID(c,k);
      } else {
            v = DataObjID(cn,k);
      }
    } else {
      std::cerr << "Unable to instantiate a DataObjID from a Property " << s 
            << " :: Format is bad" << std::endl;
      sc = StatusCode::FAILURE;
      return sc;
    }
    
      }
      return sc;
    }
     
//---------------------------------------------------------------------------

    StatusCode 
    parse (DataObjIDColl& v, const std::string& s)  {
      // default values
      StatusCode sc(StatusCode::FAILURE);
      std::string prop;
      sc = Gaudi::Parsers::parse(prop, s);
        
      if (sc.isSuccess()) {

    // Reset Collection
    v.clear();

    bool isGaudi(true);

    // Gaudi style [ '/path/to/data', '/other/data' ] or 
    // ATLAS style [ ('ClassName', 'key') , (ClassID, 'key2') ]
    if (s.find("(") != std::string::npos) {
      isGaudi = false;
    }

        // split the string in 1 or 2 words: 
        typedef boost::tokenizer<boost::char_separator<char> > tokenizer;
        boost::char_separator<char> sep("[](), ");
        tokenizer tokens(prop, sep);
        auto it = tokens.begin();

    CLID c(0);
    std::string cn;

        while (it != tokens.end()) {

      if (isGaudi) {
        v.emplace( DataObjID( *it ) );
        ++it;

      } else {
      
        try {
          c = std::stoi(*it);
        } catch (const std::invalid_argument& /*e*/)  {
          // class name, not ClassID
          cn = *it;
          boost::erase_all(cn,"'");
          c = 0;
        }
      
        ++it;
        std::string k = *it;
        boost::erase_all(k,"'");
        ++it;
      
        if ( c != 0) {
          v.emplace( DataObjID(c,k) );
        } else {
              v.emplace( DataObjID(cn,k) );
        }       
      }
        }
      }
      return sc;
    }
    

    
  } //> ns Parsers

  namespace Utils {
    
    std::ostream& 
    toStream(const DataObjID& v, std::ostream& o) {
      if (v.clid() == 0) {
    o << "'" << v.key() << "'";
      } else {
    o << "(" << v.clid() << ",'" << v.key() << "')";
      }
      return o;
    }

    std::ostream& 
    toStream(const DataObjIDColl& v, std::ostream& o) {
      o << "[";
      for (auto &i : v) {
    toStream(i,o);
    o << ",";
      }
      o << "]";
      return o;
    }
    
  } //> ns Utils
  
} //> ns Gaudi

//---------------------------------------------------------------------------

DataObjIDProperty::DataObjIDProperty( const std::string& name, 
                                      DataObjID& ref )
  : Property( name, typeid( DataObjID ) ), 
    m_pValue( &ref ) 
{}

//---------------------------------------------------------------------------

DataObjIDProperty::~DataObjIDProperty()
{}

//---------------------------------------------------------------------------

StatusCode 
DataObjIDProperty::fromString(const std::string& s)
{
  if (!Gaudi::Parsers::parse(*m_pValue, s).isSuccess()) {
    return StatusCode::FAILURE;
  }
  return useUpdateHandler()
    ? StatusCode::SUCCESS
    : StatusCode::FAILURE;
}

//---------------------------------------------------------------------------

bool
DataObjIDProperty::setValue( const DataObjID& value ) 
{
  m_pValue->operator=(value);
  return useUpdateHandler();
}

//---------------------------------------------------------------------------

std::string
DataObjIDProperty::toString( ) const 
{
  useReadHandler();
  std::ostringstream o;
  Gaudi::Utils::toStream(*m_pValue, o);
  return o.str();
}

//---------------------------------------------------------------------------
void
DataObjIDProperty::toStream(std::ostream& out) const
{
  useReadHandler();
  out << this->toString();
}


//---------------------------------------------------------------------------
//---------------------------------------------------------------------------

DataObjIDCollProperty::DataObjIDCollProperty( const std::string& name, 
                                      DataObjIDColl& ref )
  : Property( name, typeid( DataObjIDColl ) ), 
    m_pValue( &ref ) 
{}

//---------------------------------------------------------------------------

DataObjIDCollProperty::~DataObjIDCollProperty()
{}

//---------------------------------------------------------------------------

StatusCode 
DataObjIDCollProperty::fromString(const std::string& s)
{
  if (!Gaudi::Parsers::parse(*m_pValue, s).isSuccess()) {
    return StatusCode::FAILURE;
  }
  return useUpdateHandler()
    ? StatusCode::SUCCESS
    : StatusCode::FAILURE;
}

//---------------------------------------------------------------------------

bool
DataObjIDCollProperty::setValue( const DataObjIDColl& value ) 
{
  m_pValue->operator=(value);
  return useUpdateHandler();
}

//---------------------------------------------------------------------------

std::string
DataObjIDCollProperty::toString( ) const 
{
  useReadHandler();
  std::ostringstream o;
  Gaudi::Utils::toStream(*m_pValue, o);
  return o.str();
}

//---------------------------------------------------------------------------
void
DataObjIDCollProperty::toStream(std::ostream& out) const
{
  useReadHandler();
  out << this->toString();
}