---

Property.h

Go to the documentation of this file.

// $Header: /nfs/slac/g/glast/ground/cvs/GaudiKernel/GaudiKernel/Property.h,v 1.1.1.1 2001/04/18 18:14:18 tlindner Exp $
#ifndef GAUDIKERNEL_PROPERTY_H
#define GAUDIKERNEL_PROPERTY_H

/**********************************************************
 *   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".
 **********************************************************/

// Application C++ Class Headers
#include "GaudiKernel/Kernel.h"
#include "GaudiKernel/PropertyCallbackFunctor.h"
#include "GaudiKernel/PropertyVerifier.h"

// Standard C++ Class Headers
#include <string>
#include <vector>
#include <typeinfo>
#include <iosfwd>
#include <stdexcept>

// Forward delarations
class Property;

// PropertyRef is now a synonym for Property
typedef Property PropertyRef;

class Property {
public:
  // Constructors - no public constructors
  // Copy Constructor - compiler generated default is ok
  // Destructor
  virtual ~Property() {
      if ( 0 != m_readCallback ) {
          delete m_readCallback;
          m_readCallback = 0;
      }
      if ( 0 != m_updateCallback ) {
          delete m_updateCallback;
          m_updateCallback = 0;
      }
  };

  // Operators - compiler generated assignment is ok

  // Accessor members (const)
  const   std::string&    name()      const  { return m_name; };
  const   std::type_info& type_info() const  { return *m_type_info; };
  const   std::string     type()      const  { return m_type_info->name(); };
  virtual bool            isRef()     const = 0;  // Does this property reference value?
  virtual const PropertyCallbackFunctor*
                          readCallback()   const { return m_readCallback; };
  virtual const PropertyCallbackFunctor*
                          updateCallback() const { return m_updateCallback; };

  // Modifier members
  void    setName( const std::string& name ) { m_name = name; };
  void    setType( const std::string& type ); // Deprecated and unimplemented.

  // Extractors (by abuse of language)
  virtual std::istream& nameAndValueFromStream( std::istream& );
          std::istream& nameFromStream(  std::istream& );
  virtual std::istream& valueFromStream( std::istream& ) = 0;
  // Insertor (by abuse of language)
  virtual std::ostream& nameAndValueAsStream( std::ostream& ) const = 0;

  // Function members
  virtual PropertyRef* cloneRef() const = 0;    // Client owns returned heap PropertyRef.
  virtual bool load ( Property& destination ) const = 0;   // from argument
  virtual bool assign( const Property& source ) = 0;       // to   argument

  // Callback functions return void and take a Property& as argument
  void    declareReadHandler( void ( * callbackFunctionPointer ) ( Property& ) )
  {
     delete m_readCallback;
     m_readCallback = new PropertyCallbackPointerFunctor( callbackFunctionPointer );
  }
  template< class HT >
  void    declareReadHandler( void ( HT::* callbackMemberPointer ) ( Property& ), HT* instance )
  {
    delete m_readCallback;
    m_readCallback = new PropertyCallbackMemberFunctor< HT >( callbackMemberPointer, instance );
  }

  void    declareUpdateHandler( void ( * callbackFunctionPointer ) ( Property& ) )
  {
     delete m_updateCallback;
     m_updateCallback = new PropertyCallbackPointerFunctor( callbackFunctionPointer );
  }
  template< class HT >
  void    declareUpdateHandler( void ( HT::* callbackMemberPointer ) ( Property& ), HT* instance )
  {
    delete m_updateCallback;
    m_updateCallback = new PropertyCallbackMemberFunctor< HT >( callbackMemberPointer, instance );
  }

  // HACK - DO NOT USE
  // Only needed until partial template specialization arrives
  virtual std::ostream&    valueElementAsStream(   std::ostream&, size_t index ) const = 0;
  virtual std::istream&    valueElementFromStream( std::istream& ) = 0;
  struct  bad_call { };    // Exception type

protected:
  // Constructor
  Property( const std::string&    name, 
            const std::type_info& type_info )    
        : m_name( name ),
          m_type_info( &type_info ),
          m_readCallback( 0 ),
          m_updateCallback( 0 ) { };

  // Data members
  std::string  m_name;
  const std::type_info*  m_type_info;
  PropertyCallbackFunctor* m_readCallback;
  PropertyCallbackFunctor* m_updateCallback;
};

template< class T, class VT = BoundedVerifier< T > >
class SimpleProperty : public Property {
public:
  // Data and Function Members for Collaborators.
  // Constructors
  SimpleProperty() : Property( std::string(), typeid( T )) { }
  SimpleProperty( const T& value ) : Property( std::string(), typeid( T )) ,
                                     m_value( const_cast< T& >( value ) ) { }
  SimpleProperty( const std::string& name, 
                  const T& value ) : Property( name, typeid( value )) ,
                                     m_value( const_cast< T& >( value ) ) { }
  SimpleProperty( const std::string& name, 
                  const T& value, 
                  VT& verifier ) : Property( name, typeid( value ) ), 
                                   m_value( const_cast< T& >( value ) ),
                                   m_verifier( const_cast< VT& >( verifier ) ) { }


  // Copy Constructor - compiler generated default is ok
  // Destructor
  virtual ~SimpleProperty() { };

  // Operators - compiler generated assignment is ok
  SimpleProperty< T, VT >& operator=( const T& value ) {
    if ( !set( value ) ) {
      throw std::out_of_range( "Value not verified" );
    }
    return *this;
  }

  // Convertors
  operator const T&() const { return value( ); }

  const T& value() const {
    if ( 0 != m_readCallback ) ( *m_readCallback )( const_cast<SimpleProperty<T,VT>&>(*this) );
    return m_value;
  }

  VT& verifier() { return m_verifier; }            

  bool set( const T& value ) {
    bool result = false;
    if ( m_verifier.isValid( &value ) ) {
      m_value = value;
      if ( 0 != m_updateCallback ) ( *m_updateCallback )( *this );
      result = true;
    }
    return result;
  }
  bool setValue( const T& value ) { return set( value ); }    

  // Accessor members (const)
  bool isRef() const { return false; }

  // Extractors (by abuse of language)
  std::istream& nameAndValueFromStream( std::istream& );
  std::istream& valueFromStream( std::istream& );

  // Insertor (by abuse of language)
  std::ostream& nameAndValueAsStream( std::ostream& ) const;

  // Function members
  virtual PropertyRef* cloneRef() const;
  virtual bool assign( const Property& );
  virtual bool load( Property& ) const;

  // HACK - DO NOT USE
  // Only needed until partial template specialization arrives
  std::ostream& valueElementAsStream(   std::ostream&, size_t index ) const;
  std::istream& valueElementFromStream( std::istream& );

    // Data members
  T   m_value;
  VT  m_verifier;
};

template< class T, class VT = NullVerifier< T > >
class SimplePropertyRef : public Property {
public:
  // Data and Function Members for Collaborators.
  // Constructors
  SimplePropertyRef( const std::string& name, 
                     const T& value, 
                     const VT& verifier = NullVerifier<T>::theNullVerifier() )
                   : Property( name, typeid( value ) ), 
                     m_value( const_cast< T& >( value ) ),
                     m_verifier( const_cast< VT& >( verifier ) )  { }



  // Copy Constructor - compiler generated default is ok
  // Destructor
  virtual ~SimplePropertyRef() { };
  // Operators - compiler generated assignment is ok
  // Operators - compiler generated assignment is ok
  SimplePropertyRef< T, VT >& operator=( const T& value ) {
    if ( !set( value ) ) {
      throw std::out_of_range( "Value not verified" );
    }
    return *this;
  }

  // Convertors
  operator const T&() const { return value( ); }

  const T& value() const {
    if ( 0 != m_readCallback ) ( *m_readCallback )( const_cast<SimplePropertyRef<T,VT>&>(*this) );
    return m_value;
  }

  VT& verifier() { return m_verifier; }            

  bool set( const T& value ) {
    bool result = false;
    if ( m_verifier.isValid( &value ) ) {
      if ( 0 != m_updateCallback ) ( *m_updateCallback )( *this );
      m_value = value;
      result = true;
    }
    return result;
  }
  bool setValue( const T& value ) { return set( value ); }    

  // Accessor members (const)
  bool isRef() const { return true; }

  // Extractors (by abuse of language)
  std::istream& nameAndValueFromStream( std::istream& );
  std::istream& valueFromStream(     std::istream& );

  // Insertor (by abuse of language)
  std::ostream& nameAndValueAsStream(   std::ostream& ) const;

  // Function members
  virtual PropertyRef* cloneRef() const;
  virtual bool assign( const Property& );
  virtual bool load( Property& ) const;

  // HACK - DO NOT USE
  // Only needed until partial template specialization arrives
  std::ostream& valueElementAsStream( std::ostream&, size_t index ) const;
  std::istream& valueElementFromStream( std::istream& );

      // Data members
  T&   m_value;
  VT&  m_verifier;

};


// Typedef Properties for built-in types
typedef SimpleProperty< bool >              BooleanProperty;
typedef SimpleProperty< char >              CharProperty;
typedef SimpleProperty< signed char >       SignedCharProperty;
typedef SimpleProperty< unsigned char >     UnsignedCharProperty;
typedef SimpleProperty< short >             ShortProperty;
typedef SimpleProperty< unsigned short >    UnsignedShortProperty;
typedef SimpleProperty< int >               IntegerProperty;
typedef SimpleProperty< unsigned int >      UnsignedIntegerProperty;
typedef SimpleProperty< long >              LongProperty;
typedef SimpleProperty< unsigned long >     UnsignedLongProperty;
typedef SimpleProperty< float >             FloatProperty;
typedef SimpleProperty< double >            DoubleProperty;
typedef SimpleProperty< long double >       LongDoubleProperty;

typedef SimpleProperty< std::string >       StringProperty;


// Typedef PropertyRefs for built-in types
typedef SimplePropertyRef< bool >           BooleanPropertyRef;
typedef SimplePropertyRef< char >           CharPropertyRef;
typedef SimplePropertyRef< signed char >    SignedCharPropertyRef;
typedef SimplePropertyRef< unsigned char >  UnsignedCharPropertyRef;
typedef SimplePropertyRef< short >          ShortPropertyRef;
typedef SimplePropertyRef< unsigned short > UnsignedShortPropertyRef;
typedef SimplePropertyRef< int >            IntegerPropertyRef;
typedef SimplePropertyRef< unsigned int >   UnsignedIntegerPropertyRef;
typedef SimplePropertyRef< long >           LongPropertyRef;
typedef SimplePropertyRef< unsigned long >  UnsignedLongPropertyRef;
typedef SimplePropertyRef< float >          FloatPropertyRef;
typedef SimplePropertyRef< double >         DoublePropertyRef;
typedef SimplePropertyRef< long double >    LongDoublePropertyRef;

typedef SimplePropertyRef< std::string >    StringPropertyRef;


// Typedef "Arrays" of Properties for built-in types
typedef SimpleProperty< std::vector< bool > >           BooleanArrayProperty;
typedef SimpleProperty< std::vector< char > >           CharArrayProperty;
typedef SimpleProperty< std::vector< signed char > >    SignedCharArrayProperty;
typedef SimpleProperty< std::vector< unsigned char > >  UnsignedCharArrayProperty;
typedef SimpleProperty< std::vector< short > >          ShortArrayProperty;
typedef SimpleProperty< std::vector< unsigned short > > UnsignedShortArrayProperty;
typedef SimpleProperty< std::vector< int > >            IntegerArrayProperty;
typedef SimpleProperty< std::vector< unsigned int > >   UnsignedIntegerArrayProperty;
typedef SimpleProperty< std::vector< long > >           LongArrayProperty;
typedef SimpleProperty< std::vector< unsigned long > >  UnsignedLongArrayProperty;
typedef SimpleProperty< std::vector< float > >          FloatArrayProperty;
typedef SimpleProperty< std::vector< double > >         DoubleArrayProperty;
typedef SimpleProperty< std::vector< long double > >    LongDoubleArrayProperty;

typedef SimpleProperty< std::vector< std::string > >    StringArrayProperty;


// Typedef "Arrays" of PropertyRefs for built-in types
typedef SimplePropertyRef< std::vector< bool > >            BooleanArrayPropertyRef;
typedef SimplePropertyRef< std::vector< char > >            CharArrayPropertyRef;
typedef SimplePropertyRef< std::vector< signed char > >     SignedCharArrayPropertyRef;
typedef SimplePropertyRef< std::vector< unsigned char > >   UnsignedCharArrayPropertyRef;
typedef SimplePropertyRef< std::vector< short > >           ShortArrayPropertyRef;
typedef SimplePropertyRef< std::vector< unsigned short > >  UnsignedShortArrayPropertyRef;
typedef SimplePropertyRef< std::vector< int > >             IntegerArrayPropertyRef;
typedef SimplePropertyRef< std::vector< unsigned int > >    UnsignedIntegerArrayPropertyRef;
typedef SimplePropertyRef< std::vector< long > >            LongArrayPropertyRef;
typedef SimplePropertyRef< std::vector< unsigned long > >   UnsignedLongArrayPropertyRef;
typedef SimplePropertyRef< std::vector< float > >           FloatArrayPropertyRef;
typedef SimplePropertyRef< std::vector< double > >          DoubleArrayPropertyRef;
typedef SimplePropertyRef< std::vector< long double > >     LongDoubleArrayPropertyRef;

typedef SimplePropertyRef< std::vector< std::string > >     StringArrayPropertyRef;


#endif // GAUDIKERNEL_PROPERTY_H

---