VarHandleKeyProperty.cxx

Go to the documentation of this file.

/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/

 
// STL includes
#include <sstream>
#include <map>
 
// StoreGate includes
#include "StoreGate/VarHandleKeyProperty.h"
 
static const char* const storeSeparator = "+";
 
namespace Gaudi { 
namespace Parsers {
 

StatusCode 
parse(SG::VarHandleKey& v, const std::string& s)
{
  std::string prop;
  StatusCode sc = Gaudi::Parsers::parse(prop, s);
  if (sc.isSuccess())
    sc = v.assign (prop);
  return sc;
}
 
} //> ns Parsers
 
namespace Utils {
 

std::ostream& 
toStream(const SG::VarHandleKey& v, std::ostream& o)
{
  o << "'" << v.storeHandle().name() << storeSeparator << v.key() << "'";
  return o;
}
    
} //> ns Utils
 
} //> ns Gaudi
 
 
namespace SG {
 

VarHandleKeyProperty::VarHandleKeyProperty( const std::string& name, 
                                            SG::VarHandleKey& ref )
  : DataHandleProperty( name, ref ),
    m_pValue( &ref ) 
{
}
 

 * @brief Assignment operator.
 * @param value Value from which to assign.
 *
 * Copy the value object which we control from another value object.
 */
VarHandleKeyProperty& 
VarHandleKeyProperty::operator=( const SG::VarHandleKey& value ) 
{
  setValue( value );
  return *this;
}
 

VarHandleKeyProperty* 
VarHandleKeyProperty::clone() const 
{
  return new VarHandleKeyProperty( *this );
}
 

bool
VarHandleKeyProperty::load( Gaudi::Details::PropertyBase& destination ) const 
{
  return destination.assign( *this );
}
 

bool
VarHandleKeyProperty::assign( const Gaudi::Details::PropertyBase& source ) 
{
  return fromString( source.toString() ).isSuccess();
}
 

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

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

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

const SG::VarHandleKey& 
VarHandleKeyProperty::value() const 
{
  useReadHandler();
  return *m_pValue;
}
 

bool
VarHandleKeyProperty::setValue( const SG::VarHandleKey& value ) 
{
  m_pValue->operator=(value);
  return useUpdateHandler();
}
 
 
}  // namespace SG