---

Property.cpp

Go to the documentation of this file.

// $Header: /nfs/slac/g/glast/ground/cvs/GaudiKernel/src/Lib/Property.cpp,v 1.1.1.1 2001/04/18 18:14:18 tlindner Exp $
/**********************************************************
 *   This component supplies SimpleProperty's, that own
 *   their value's memory, and SimplePropertyRef's, that
 *   refer to their value's memory, for all fundamental
 *   types plus std::string's and std::vector's of all 
 *   fundamental types plus std::string's. Both 
 *   SimpleProperty's and SimplePropertyRef's include 
 *   Verifier's that are BoundedVerifier's by default for
 *   SimpleProperty's and NullVerifier's by default for
 *   SimplePropertyRef's. Other Verifier's may be specified
 *   as optional arguments to creators. All SimplePropery's
 *   and SimplePropertyRef's are derived from the abstract
 *   class Property so that containers of Property*'s may be
 *   "homogeneous".
 **********************************************************/

// Include files
#include "GaudiKernel/Property.h"
#include "GaudiKernel/PropertyCallbackFunctor.h"


// Standard C++ Class Headers
#include <iostream>
#include <stdexcept>


// Local helper function declarations to consolidate implementation of 
//   "Array" Properties
// N.B. - unnamed namespaces not yet available for all compilers
//        hence the static declarations. CTDay

static
std::istream&
valueFromStreamHelper( std::istream& i, Property& p );

static
std::ostream&    
nameValueAsStreamHelper( std::ostream& o, const Property& p, size_t vSize );

static char getFirstNonBlank(std::istream& i)  {
  char delim;
  while ((delim=i.get()) == ' ' ) {             // Advance to the beginning '"'
    if ( i.fail() )    {
      throw Property::bad_call();
    }
  }
  if ( delim != '"' && delim != '\'' ) i.putback(delim);         // Put char back, it's not a '"'
  return delim;
}

template <class T> 
static void getQuotedItem( std::istream& i, T& temp )    {
  char c = getFirstNonBlank(i);                 // Advance to the beginning '"'
  i >> temp;                                    // Suck value from stream
  if ( c == '"' )  {                            // Advance to the trailing '"'
    while ((c=i.get()) != '"' && !i.fail() >= 0 ) {}
  }
  else if ( c == '\'' )  {                      // Advance to the trailing '"'
    while ((c=i.get()) != '\'' && !i.fail() >= 0 ) {}
  }
}

template <> 
static void getQuotedItem( std::istream& i, std::string& temp )    {
  char c = getFirstNonBlank(i);                   // Advance to the beginning '"'
  if ( c != '"' && c != '\'' )   {
    i >> temp;
  }
  else   {
    if( c == '"' ) {
      while ( (c=i.get()) != '"' && !i.fail()) {       // Add all chars up to the next '"'
        temp += c;
      }
    }
    else if( c == '\'' ) {
      while ( (c=i.get()) != '\'' && !i.fail()) {       // Add all chars up to the next '"'
        temp += c;
      }
    }
  }
}

//---------------------------------------------------------------------------------------------
// Property
//---------------------------------------------------------------------------------------------
/* Extractor */
std::istream&
Property::nameFromStream( std::istream& i ) {
  i >> m_name;
  m_name =  m_name.substr( 1, m_name.length() - 3 );    // Strip quotes & ":"
  i.ignore();                                           // Skip " "
  return i;
}

/* Insertor */
std::istream&
Property::nameAndValueFromStream( std::istream& i ) {
  nameFromStream( i );
  valueFromStream( i );
  return i;
}


/* Extractors */
template< class T, class VT >
std::istream&
SimpleProperty< T, VT >::nameAndValueFromStream( std::istream& i ) {
  return Property::nameAndValueFromStream( i );
}

template< class T, class VT >
std::istream&
SimpleProperty< T, VT >::valueFromStream( std::istream& i ) {
  T value;

  i >> value;
  if ( !set( value ) ) {
    throw std::out_of_range( "Value not verified" );
  }
  return i;
}

/* Insertor */
template< class T, class VT >
std::ostream&
SimpleProperty< T, VT >::nameAndValueAsStream( std::ostream& o ) const {
  return o << "\"" << m_name << "\": " << m_value;
}

/* Public Function Members */
template< class T, class VT >
Property* 
SimpleProperty< T, VT >::cloneRef() const {
   return new SimplePropertyRef< T, VT >( m_name, m_value, m_verifier );
}

template< class T, class VT >
bool
SimpleProperty< T, VT >::assign( const Property& p ) {
  typedef SimpleProperty< T >     TypedProperty;
  typedef SimplePropertyRef< T >  TypedPropertyRef;

  if( p.isRef() ) {
    const TypedPropertyRef& tp = dynamic_cast< const TypedPropertyRef& > ( p );
    return set( tp.value() );
  } else {
    const TypedProperty& tp = dynamic_cast< const TypedProperty& > ( p );
    return set( tp.value() );
  }
}

template< class T, class VT >
bool
SimpleProperty< T, VT >::load( Property& p ) const {
  typedef SimpleProperty< T >     TypedProperty;
  typedef SimplePropertyRef< T >  TypedPropertyRef;

  if( p.isRef() ) {
    TypedPropertyRef& tp = dynamic_cast< TypedPropertyRef& > ( p );
    return tp.set( m_value );
  } else {
    TypedProperty& tp = dynamic_cast< TypedProperty& > ( p );
    return tp.set( m_value );
  }
}

/* HACK Extractors */
template< class T, class VT >
std::ostream&
SimpleProperty< T, VT >::valueElementAsStream( std::ostream& o, size_t ) const {
  throw bad_call();
  return o;
}

template< class T, class VT >
std::istream&
SimpleProperty< T, VT >::valueElementFromStream( std::istream& i ) {
  throw bad_call();
  return i;
}

//---------------------------------------------------------------------------------------------
// SimpleProperty specializations
//---------------------------------------------------------------------------------------------
/* Extractor */
// std::string values need quotes stripped
template<>
std::istream&
SimpleProperty< std::string, 
                BoundedVerifier< std::string > >::valueFromStream( std::istream& i )  {
  std::string value;
  getQuotedItem(i, value);
  if ( !set( value ) ) {
    throw std::out_of_range( "Value not verified" );
  }
  return i;
}

/* Insertor */
// std::string values need quotes
template<>
std::ostream&
SimpleProperty< std::string, 
                BoundedVerifier< std::string > >::nameAndValueAsStream( std::ostream& o ) const  {
  return o << "\"" << m_name << "\": " << "\"" << m_value << "\"";
}

//---------------------------------------------------------------------------------------------
// SimplePropertyRef
//---------------------------------------------------------------------------------------------
/* Extractors */
template< class T, class VT >
std::istream&
SimplePropertyRef< T, VT >::nameAndValueFromStream( std::istream& i ) {
  return Property::nameAndValueFromStream( i );
}

template< class T, class VT >
std::istream&
SimplePropertyRef< T, VT >::valueFromStream( std::istream& i ) {
  T value;

  i >> value;
  if ( !set( value ) ) {
    throw std::out_of_range( "Value not verified" );
  }
  return i;
}

/* Insertor */
template< class T, class VT >
std::ostream&
SimplePropertyRef< T, VT >::nameAndValueAsStream( std::ostream& o ) const {
  return o << "\"" << m_name << "\": " << value();
}

/* Public Function Members */
template< class T, class VT >
Property*
SimplePropertyRef< T, VT >::cloneRef() const {
  return new SimplePropertyRef< T, VT >( m_name, m_value, m_verifier );
}

template< class T, class VT >
bool
SimplePropertyRef< T, VT >::assign( const Property& p ) {
  typedef SimpleProperty< T >     TypedProperty;
  typedef SimplePropertyRef< T >  TypedPropertyRef;

  if( p.isRef() ) {
    const TypedPropertyRef& tp = dynamic_cast< const TypedPropertyRef& > ( p );
    return set( tp.value() );
  } else {
    const TypedProperty& tp = dynamic_cast< const TypedProperty& > ( p );
    return set( tp.value() );
  }
}

template< class T, class VT >
bool
SimplePropertyRef< T, VT >::load( Property& p ) const {
  typedef SimpleProperty< T >     TypedProperty;
  typedef SimplePropertyRef< T >  TypedPropertyRef;

  if( p.isRef() ) {
    TypedPropertyRef& tp = dynamic_cast< TypedPropertyRef& > ( p );
    return tp.set( m_value );
  } else {
    TypedProperty& tp = dynamic_cast< TypedProperty& > ( p );
    return tp.set( m_value );
  }
}

/* HACK Extractors */
template< class T, class VT >
std::ostream&
SimplePropertyRef< T, VT >::valueElementAsStream( std::ostream& o, size_t ) const {
  throw bad_call();
  return o;
}

template< class T, class VT >
std::istream&
SimplePropertyRef< T, VT >::valueElementFromStream( std::istream& i ) {
  throw bad_call();
  return i;
}

//---------------------------------------------------------------------------------------------
// SimplePropertyRef specializations
//---------------------------------------------------------------------------------------------
/* Extractor */
// std::string values need quotes stripped
template<> 
std::istream&
SimplePropertyRef< std::string,
                   NullVerifier< std::string > >::valueFromStream( std::istream& i ) {
  std::string value;
  getQuotedItem(i, value);
  if ( !set( value ) ) {
    throw std::out_of_range( "Value not verified" );
  }
  return i;
}

/* Insertor */
// std::string values need quotes
template<> 
std::ostream&
SimplePropertyRef< std::string, 
                   NullVerifier< std::string > >::nameAndValueAsStream( std::ostream& o ) const {
  return o << "\"" << m_name << "\": " << "\"" << m_value << "\"";
}

/* Extractor */
// StringProperty values need quotes stripped
template<> 
std::istream&
SimplePropertyRef< std::string,
                   BoundedVerifier< std::string > >::valueFromStream( std::istream& i ) {
  std::string value;
  i >> value;
  value = value.substr( 1, value.length() - 2 );    // Strip quotes
  if ( !set( value ) ) {
      throw std::out_of_range( "Value not verified" );
  }
  return i;
}

/* Insertor */
// StringProperty values need quotes
template<> 
std::ostream&
SimplePropertyRef< std::string, 
                   BoundedVerifier< std::string > >::nameAndValueAsStream( std::ostream& o ) const {
  return o << "\"" << m_name << "\": " << "\"" << m_value << "\"";
}


//---------------------------------------------------------------------------------------------
// "Array" Property specializations
//---------------------------------------------------------------------------------------------
// HACK Big Time
// Vile macro to be disposed of once partial template specialization
// exists in all the compilers.

#define UNQUOTEDELEMENTOUTPUT return o << m_value[ix];
#define QUOTEDELEMENTOUTPUT   return o << "\"" << m_value[ix] << "\"";
#define UNQUOTEDELEMENTINPUT  i >> temp;
// #define QUOTEDELEMENTINPUT    i >> temp; i.putback( temp[temp.length()-1] ); temp = temp.substr( 1, temp.length() - 3 ); 
#define QUOTEDELEMENTINPUT    getQuotedItem(i, temp);

#define ARRAYPROPERTIES(TYPENAME,BASETYPE,QUOTESTYLE) \
template<> \
std::ostream& \
TYPENAME##ArrayProperty::nameAndValueAsStream( std::ostream& o ) const \
{ \
    return nameValueAsStreamHelper( o, *this, value().size() ); \
} \
 \
template<> \
std::istream& \
TYPENAME##ArrayProperty::valueFromStream( std::istream& i ) \
{ \
    m_value.clear(); \
    std::istream& result = valueFromStreamHelper( i, *this ); \
    if ( 0 != m_updateCallback ) ( *m_updateCallback )( *this );  \
    return result;  \
} \
 \
template<> \
std::istream& \
TYPENAME##ArrayProperty::nameAndValueFromStream( std::istream& i ) \
{ \
    m_name.erase(); \
    m_value.clear(); \
    nameFromStream( i ); \
    return valueFromStream( i ); \
} \
 \
template<> \
std::ostream& \
TYPENAME##ArrayProperty::valueElementAsStream( std::ostream& o, size_t ix ) const \
{ \
    QUOTESTYLE##ELEMENTOUTPUT \
} \
 \
template<> \
std::istream& \
TYPENAME##ArrayProperty::valueElementFromStream( std::istream& i ) \
{ \
    BASETYPE temp; \
    QUOTESTYLE##ELEMENTINPUT \
    m_value.push_back( temp ); \
    return i; \
} \
 \
 \
/* PropertyMgr will need (default) ClonedRefs of any (default) SimpleProperty */ \
typedef SimplePropertyRef< std::vector< BASETYPE >, \
                           BoundedVerifier< std::vector< BASETYPE > > > \
            Cloned##TYPENAME##ArrayPropertyRef; \
template<> \
std::ostream& \
Cloned##TYPENAME##ArrayPropertyRef::nameAndValueAsStream( std::ostream& o ) const \
{ \
    return nameValueAsStreamHelper( o, *this, value().size() ); \
} \
 \
template<> \
std::istream& \
Cloned##TYPENAME##ArrayPropertyRef::valueFromStream( std::istream& i ) \
{ \
    m_value.clear(); \
    std::istream& result = valueFromStreamHelper( i, *this ); \
    if ( 0 != m_updateCallback ) ( *m_updateCallback )( *this );  \
    return result;  \
} \
 \
template<> \
std::istream& \
Cloned##TYPENAME##ArrayPropertyRef::nameAndValueFromStream( std::istream& i ) \
{ \
    m_name.erase(); \
    m_value.clear(); \
    nameFromStream( i ); \
    return valueFromStream( i ); \
} \
 \
template<> \
std::ostream& \
Cloned##TYPENAME##ArrayPropertyRef::valueElementAsStream( std::ostream& o, size_t ix ) const \
{ \
    QUOTESTYLE##ELEMENTOUTPUT \
} \
 \
template<> \
std::istream& \
Cloned##TYPENAME##ArrayPropertyRef::valueElementFromStream( std::istream& i ) \
{ \
    BASETYPE temp; \
    QUOTESTYLE##ELEMENTINPUT \
    m_value.push_back( temp ); \
    return i; \
} \


ARRAYPROPERTIES(Boolean,bool,UNQUOTED)
ARRAYPROPERTIES(Char,char,UNQUOTED)
ARRAYPROPERTIES(SignedChar,signed char,UNQUOTED)
ARRAYPROPERTIES(UnsignedChar,unsigned char,UNQUOTED)
ARRAYPROPERTIES(Short,short,UNQUOTED)
ARRAYPROPERTIES(UnsignedShort,unsigned short,UNQUOTED)
ARRAYPROPERTIES(Integer,int,UNQUOTED)
ARRAYPROPERTIES(UnsignedInteger,unsigned int,UNQUOTED)
ARRAYPROPERTIES(Long,long,UNQUOTED)
ARRAYPROPERTIES(UnsignedLong,unsigned long,UNQUOTED)
ARRAYPROPERTIES(Float,float,UNQUOTED)
ARRAYPROPERTIES(Double,double,UNQUOTED)
ARRAYPROPERTIES(LongDouble,long double,UNQUOTED)

ARRAYPROPERTIES(String,std::string,QUOTED)
#undef ARRAYPROPERTIES

//---------------------------------------------------------------------------------------------
// "Array" PropertyRef specializations
//---------------------------------------------------------------------------------------------
// HACK Big Time
// Vile macro to be disposed of once partial template specialization
// exists in all the compilers.

#define ARRAYPROPERTYREFS(TYPENAME,BASETYPE,QUOTESTYLE) \
\
\
template<> \
std::ostream& \
TYPENAME##ArrayPropertyRef::nameAndValueAsStream( std::ostream& o ) const \
{ \
    return nameValueAsStreamHelper( o, *this, value().size() ); \
} \
 \
template<> \
std::istream& \
TYPENAME##ArrayPropertyRef::valueFromStream( std::istream& i ) \
{ \
    m_value.clear(); \
    std::istream& result = valueFromStreamHelper( i, *this ); \
    if ( 0 != m_updateCallback ) ( *m_updateCallback )( *this );  \
    return result;  \
} \
 \
template<> \
std::istream& \
TYPENAME##ArrayPropertyRef::nameAndValueFromStream( std::istream& i ) \
{ \
    m_name.erase(); \
    m_value.clear(); \
    nameFromStream( i ); \
    return valueFromStream( i ); \
} \
 \
template<> \
std::ostream& \
TYPENAME##ArrayPropertyRef::valueElementAsStream( std::ostream& o, size_t ix ) const \
{ \
    QUOTESTYLE##ELEMENTOUTPUT \
} \
 \
template<> \
std::istream& \
TYPENAME##ArrayPropertyRef::valueElementFromStream( std::istream& i ) \
{ \
    BASETYPE temp; \
    QUOTESTYLE##ELEMENTINPUT \
    m_value.push_back( temp ); \
    return i; \
} \


ARRAYPROPERTYREFS(Boolean,bool,UNQUOTED)
ARRAYPROPERTYREFS(Char,char,UNQUOTED)
ARRAYPROPERTYREFS(SignedChar,signed char,UNQUOTED)
ARRAYPROPERTYREFS(UnsignedChar,unsigned char,UNQUOTED)
ARRAYPROPERTYREFS(Short,short,UNQUOTED)
ARRAYPROPERTYREFS(UnsignedShort,unsigned short,UNQUOTED)
ARRAYPROPERTYREFS(Integer,int,UNQUOTED)
ARRAYPROPERTYREFS(UnsignedInteger,unsigned int,UNQUOTED)
ARRAYPROPERTYREFS(Long,long,UNQUOTED)
ARRAYPROPERTYREFS(UnsignedLong,unsigned long,UNQUOTED)
ARRAYPROPERTYREFS(Float,float,UNQUOTED)
ARRAYPROPERTYREFS(Double,double,UNQUOTED)
ARRAYPROPERTYREFS(LongDouble,long double,UNQUOTED)

ARRAYPROPERTYREFS(String,std::string,QUOTED)
#undef ARRAYPROPERTYREFS



/**********************************
 * C DEFINITION SECTION
 *   Internal Functions Sub-section
 **********************************/
/* Internal Function Definitions */
// To consolidate implementation of 
// "Array" Properties
static
std::istream&
valueFromStreamHelper( std::istream& i, Property& p )
{
    char   c;

    i.ignore();                                 // Skip "["
    i.get( c );                                 // Position at next token
    while ( ']' != c && !i.fail() ) {           // Test for array end
        i.putback( c );                         // Ready to read value element
        p.valueElementFromStream( i );          // Read value element
        i.get( c );                             // Position to next token
        if ( ',' == c ) {                       // More value elements
            i.get( c );                         // Position to next token
        }
    }
    return i;
};

static
std::ostream&    
nameValueAsStreamHelper( std::ostream& o, const Property& p, size_t vSize )
{
    if ( 0 == vSize ) {
        o << "\"" << p.name() << "\": []";        // Empty array
    }
    else {
        o << "\"" << p.name() << "\": [";         // Open array
        for ( size_t ix = 0; ix < vSize; ++ix ) {
            p.valueElementAsStream( o, ix ); 
            o << ( ( vSize == ( ix+1 ) )          // Last element?
                ? "]"                             // Yes - Close array
                : ", " );                         // No  - Prepare for element
        }
    }
    return o;
};


//---------------------------------------------------------------------------------------------
// [Explicit instantiations]
//   Force instantiation of all member functions

#ifdef WIN32
  // Disable warning C4660: template-class specialization 'identifier' is already instantiated
  #pragma warning ( disable : 4660 )
#endif    // WIN32

template class SimpleProperty< bool >;
template class SimpleProperty< char >;
template class SimpleProperty< signed char >;
template class SimpleProperty< unsigned char >;
template class SimpleProperty< short >;
template class SimpleProperty< unsigned short >;
template class SimpleProperty< int >;
template class SimpleProperty< unsigned int >;
template class SimpleProperty< long >;
template class SimpleProperty< unsigned long >;
template class SimpleProperty< float >;
template class SimpleProperty< double >;
template class SimpleProperty< long double >;

template class SimpleProperty< std::string >;

template class SimplePropertyRef< bool >;
template class SimplePropertyRef< char >;
template class SimplePropertyRef< signed char >;
template class SimplePropertyRef< unsigned char >;
template class SimplePropertyRef< short >;
template class SimplePropertyRef< unsigned short >;
template class SimplePropertyRef< int >;
template class SimplePropertyRef< unsigned int >;
template class SimplePropertyRef< long >;
template class SimplePropertyRef< unsigned long >;
template class SimplePropertyRef< float >;
template class SimplePropertyRef< double >;
template class SimplePropertyRef< long double >;

template class SimplePropertyRef< std::string >;

template class SimpleProperty< std::vector< bool > >;
template class SimpleProperty< std::vector< char > >;
template class SimpleProperty< std::vector< signed char > >;
template class SimpleProperty< std::vector< unsigned char > >;
template class SimpleProperty< std::vector< short > >;
template class SimpleProperty< std::vector< unsigned short > >;
template class SimpleProperty< std::vector< int > >;
template class SimpleProperty< std::vector< unsigned int > >;
template class SimpleProperty< std::vector< long > >;
template class SimpleProperty< std::vector< unsigned long > >;
template class SimpleProperty< std::vector< float > >;
template class SimpleProperty< std::vector< double > >;
template class SimpleProperty< std::vector< long double > >;

template class SimpleProperty< std::vector< std::string > >;

template class SimplePropertyRef< std::vector< bool > >;
template class SimplePropertyRef< std::vector< char > >;
template class SimplePropertyRef< std::vector< signed char > >;
template class SimplePropertyRef< std::vector< unsigned char > >;
template class SimplePropertyRef< std::vector< short > >;
template class SimplePropertyRef< std::vector< unsigned short > >;
template class SimplePropertyRef< std::vector< int > >;
template class SimplePropertyRef< std::vector< unsigned int > >;
template class SimplePropertyRef< std::vector< long > >;
template class SimplePropertyRef< std::vector< unsigned long > >;
template class SimplePropertyRef< std::vector< float > >;
template class SimplePropertyRef< std::vector< double > >;
template class SimplePropertyRef< std::vector< long double > >;

template class SimplePropertyRef< std::vector< std::string > >;

#ifdef WIN32
  // Disable warning C4660: template-class specialization 'identifier' is already instantiated
  #pragma warning ( default : 4660 )
#endif    // WIN32

---