---

PropertyMgr.cpp

Go to the documentation of this file.

// $Header: /nfs/slac/g/glast/ground/cvs/GaudiKernel/src/Lib/PropertyMgr.cpp,v 1.1.1.1 2001/04/18 18:14:18 tlindner Exp $

// Include files

#include "GaudiKernel/PropertyMgr.h"

// strings.h does not exist on WIN32. Needed for case insensitive comparison
#ifdef WIN32
#  include <string.h>
#  define strcasecmp _stricmp
#else
#  include <strings.h>
#endif
#include <iostream>
#include <strstream>
#include <stdexcept>

PropertyMgr::PropertyMgr()  { }

PropertyMgr::~PropertyMgr() {

    // This is a kludge in order to avoid problems with a Property having
    // been deleted defore it's entry in the list is removed. Either we need
    // to clone a Property prior to the clone being inserted in the list, or
    // we need to indicate whether the Property is owned by this PropertyMgr.
    // CHris Day originally did the former, but that had template problems
    // with the Solaris compiler. This implementation uses the second
    // approach. We should probably revisit this.
    PropertyCollectionType::iterator it;
    std::vector<bool>::const_iterator itb = m_isOwned.begin( );
    for(it = m_properties.begin(); it != m_properties.end(); it++) {
        if ( (*itb) ) {
            delete (*it);
        }
        itb++;
    }
}

// Set the value of a property
StatusCode PropertyMgr::setProperty(const Property& p) {
  PropertyCollectionType::iterator it;
  // Locate the property by name
  for(it = m_properties.begin(); it != m_properties.end(); it++) {
    if( strcasecmp(((*it)->name()).c_str(), (p.name()).c_str()) == 0 ) {
      // Property found: assign value
      // An exception is thrown in the event of type mismatch
      // catch(...) is used because catch(std::bad_cast) doesn't work
      try {
        (*it)->assign(p);
      } catch(...) {
        return StatusCode::FAILURE;    // Type mismatch
      }
      return StatusCode::SUCCESS;        // Property value set
    }
  }
  return StatusCode::FAILURE;
}


StatusCode
PropertyMgr::setProperty( std::istream& i )
{
    SimpleProperty< int > modelProperty;
    modelProperty.nameFromStream( i );

    try {
        Property& actualProperty = const_cast<Property&>(getProperty( modelProperty.name( ) ));
        actualProperty.valueFromStream( i );
    } catch ( std::out_of_range ) {
        return StatusCode::FAILURE;     // Property not found
    }

    return StatusCode::SUCCESS;
}


StatusCode
PropertyMgr::setProperty( const std::string& n, const std::string& v )
{
    try {
        Property& property = const_cast<Property&>(getProperty( n ));
        std::strstream s;
        s << v ;  //<< std::ends;
        property.valueFromStream( s );
        s.freeze(false);
    } catch ( std::out_of_range ) {
        return StatusCode::FAILURE;     // Property not found
    }
    return StatusCode::SUCCESS;
}


// Retrieve the value of a property
StatusCode PropertyMgr::getProperty(Property* p) const {
  try {
    const Property& source = getProperty( p->name() );
    source.load( *p );
    return StatusCode::SUCCESS;
  }
  catch ( ... ) {
    return StatusCode::FAILURE;        // Property not found
  }
}

// Get the property by name
const Property& PropertyMgr::getProperty( const std::string& name) const {
  PropertyCollectionType::const_iterator it;
  // Locate the property by name
  for(it = m_properties.begin(); it != m_properties.end(); it++) {
    if( strcasecmp(((*it)->name()).c_str(), name.c_str()) == 0 ) {
      // Property found
      return **it;
    }
  }
  throw std::out_of_range( "Property "+name+" not found." );    // Not found
}

// Get the property by name
StatusCode PropertyMgr::getProperty( const std::string& n, std::string& v ) const {
  // This method is not implementable since the return argument is const !!!! 
  std::strstream s;
  v = "";
  try {
    const Property& property = getProperty( n );
    property.nameAndValueAsStream(s);
    while( s.get() != ':' && !s.fail() ) { }
    while( !s.fail() ) v += s.get(); 
    return StatusCode::SUCCESS;
  }
  catch ( ... ) {
    return StatusCode::FAILURE;        // Property not found
  }
}

const std::vector<Property*>& PropertyMgr::getProperties( ) const {
  return m_properties;
}


// Implementation (or not) of IInterface
StatusCode PropertyMgr::queryInterface(const IID&, void**) { return StatusCode::FAILURE; }
unsigned long PropertyMgr::addRef() { return 0; }
unsigned long PropertyMgr::release() { return 0; }

---