| # Gaudi Framework, version v25r0 |

Home |  | Generated: Mon Feb 17 2014

- Main Page
- Related Pages
- Modules
- Namespaces
- Classes
- Files

- File List
- File Members

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Groups Pages
Property.h
Go to the documentation of this file.
1 // $Id: Property.h,v 1.26 2008/10/27 16:41:34 marcocle Exp $
2 // ============================================================================
3 // CVS tag $Name: $
4 // ============================================================================
5 #ifndef GAUDIKERNEL_PROPERTY_H
6 #define GAUDIKERNEL_PROPERTY_H
7 // ============================================================================
8 // STD & STL
9 // ============================================================================
10 #include <string>
11 #include <stdexcept>
12 #include <typeinfo>
13 // ============================================================================
14 // Application C++ Class Headers
15 // ============================================================================
16 #include "GaudiKernel/Kernel.h"
17 #include "GaudiKernel/PropertyVerifier.h"
18 #include "GaudiKernel/Parsers.h"
19 #include "GaudiKernel/ToStream.h"
20 #include "GaudiKernel/SmartIF.h"
21 // ============================================================================
22
23 // ============================================================================
24 class Property ;
25 class PropertyCallbackFunctor ;
26 class IProperty ;
27 class IInterface ;
28 // ============================================================================
29
30 // ============================================================================
32 // ============================================================================
33 GAUDI_API std::ostream& operator<<(std::ostream& stream, const Property& prop);
34 // ============================================================================
43 class GAUDI_API Property
44 {
45 public:
47 const std::string& name () const { return m_name ; }
49 const std::string& documentation() const { return m_documentation; }
51 const std::type_info* type_info () const { return m_typeinfo ; }
53 std::string type () const { return m_typeinfo->name() ; }
55 virtual bool load ( Property& dest ) const = 0 ;
57 virtual bool assign ( const Property& source ) = 0 ;
58 public:
60 virtual std::string toString () const = 0 ;
62 virtual void toStream(std::ostream& out) const = 0;
64 virtual StatusCode fromString ( const std::string& value ) = 0 ;
65 public:
67 const PropertyCallbackFunctor* readCallBack () const ;
69 const PropertyCallbackFunctor* updateCallBack () const ;
71 virtual void declareReadHandler ( PropertyCallbackFunctor* pf ) ;
73 virtual void declareUpdateHandler ( PropertyCallbackFunctor* pf ) ;
74 template< class HT >
75 void declareReadHandler
76 ( void ( HT::* MF ) ( Property& ) , HT* instance ) ;
77 template< class HT >
78 void declareUpdateHandler
79 ( void ( HT::* MF ) ( Property& ) , HT* instance ) ;
81 virtual void useReadHandler () const ;
83 virtual bool useUpdateHandler () ;
84 public:
86 virtual ~Property() ;
88 virtual Property* clone () const = 0 ;
90 void setName ( const std::string& value ) { m_name = value ; }
92 void setDocumentation( const std::string& documentation ) {
93 m_documentation = documentation; }
95 virtual std::ostream& fillStream ( std::ostream& ) const ;
96 protected:
98 Property
99 ( const std::type_info& type ,
100 const std::string& name = "" ) ;
102 Property
103 ( const std::string& name ,
104 const std::type_info& type ) ;
106 Property ( const Property& right ) ;
108 Property& operator=( const Property& right ) ;
109 private:
110 // the default constructor is disabled
111 Property() ;
112 private:
113 // property name
114 std::string m_name ;
115 // property doc string
116 std::string m_documentation;
117 // property type
118 const std::type_info* m_typeinfo ;
119 protected:
120 // call back functor for reading
121 mutable PropertyCallbackFunctor* m_readCallBack ;
122 // call back functor for update
123 PropertyCallbackFunctor* m_updateCallBack ;
124 };
125 // ============================================================================
126 #include "GaudiKernel/PropertyCallbackFunctor.h"
127 // ============================================================================
128 template< class HT >
129 inline void Property::declareReadHandler
130 ( void ( HT::* MF ) ( Property& ) , HT* obj )
131 { declareReadHandler ( new PropertyCallbackMemberFunctor< HT >( MF , obj ) ) ; }
132 // ============================================================================
133 template< class HT >
134 inline void Property::declareUpdateHandler
135 ( void ( HT::* MF ) ( Property& ) , HT* obj )
136 { declareUpdateHandler ( new PropertyCallbackMemberFunctor< HT >( MF , obj ) ) ; }
137 // ============================================================================
145 // ============================================================================
146 template <class TYPE>
147 class PropertyWithValue : public Property
148 {
149 public:
150 // ==========================================================================
152 typedef Gaudi::Utils::PropertyTypeTraits<TYPE> Traits ;
154 typedef typename Traits::PVal PVal ;
155 // ==========================================================================
156 protected:
157 // ==========================================================================
159 inline PropertyWithValue
160 ( const std::string& name ,
161 PVal value ,
162 const bool owner ) ;
164 inline PropertyWithValue ( const PropertyWithValue& rhs ) ;
166 template <class OTHER>
167 inline PropertyWithValue ( const PropertyWithValue<OTHER>& right ) ;
169 virtual inline ~PropertyWithValue() ;
171 PropertyWithValue& operator=( const TYPE& value ) ;
172 // assignment operator (don't let the compiler generate a buggy one)
173 PropertyWithValue& operator=( const PropertyWithValue& rhs ) ;
174 // assignment operator
175 template <class OTHER>
176 PropertyWithValue& operator=( const PropertyWithValue<OTHER>& right ) ;
177 // ==========================================================================
178 public:
179 // ==========================================================================
181 operator const TYPE& () const { return value() ;}
183 inline const TYPE& value() const ;
184 // ==========================================================================
185 public:
186 // ==========================================================================
188 virtual bool setValue ( const TYPE& value ) = 0 ;
190 virtual bool assign ( const Property& source ) ;
192 virtual bool load ( Property& dest ) const ;
194 virtual StatusCode fromString ( const std::string& s ) ;
196 virtual std::string toString () const ;
198 virtual void toStream (std::ostream& out) const ;
199 // ==========================================================================
200 protected:
201 // ==========================================================================
203 inline void i_set ( const TYPE& value ) {
204 Traits::assign(*m_value, value);
205 }
207 inline PVal i_get () const {
208 return m_value;
209 }
210 // ==========================================================================
211 private:
212 // ==========================================================================
214 PVal m_value ; // the actual property value
216 bool m_own ; // owner of the storage
217 // ==========================================================================
218 };
219
220 // ============================================================================
222 // ============================================================================
223 template <class TYPE>
224 inline
225 PropertyWithValue<TYPE>::PropertyWithValue
226 ( const std::string& name ,
227 PVal value ,
228 const bool own )
229 : Property ( typeid( TYPE ) , name )
230 , m_value ( value )
231 , m_own ( own )
232 {}
233 // ============================================================================
234 // copy constructor
235 // ============================================================================
236 template <class TYPE>
237 inline PropertyWithValue<TYPE>::PropertyWithValue
238 ( const PropertyWithValue& right )
239 : Property( right )
240 , m_value ( right.m_value )
241 , m_own ( right.m_own )
242 {
243 m_value = Traits::copy ( right.value() , m_own ) ;
244 }
245 // ============================================================================
246 // "copy" constructor form any other type
247 // ============================================================================
248 template <class TYPE>
249 template <class OTHER>
250 inline PropertyWithValue<TYPE>::PropertyWithValue
251 ( const PropertyWithValue<OTHER>& right )
252 : Property( right )
253 , m_value ( right.m_value )
254 , m_own ( right.m_own )
255 {
256 m_value = Traits::copy ( right.value() , m_own ) ;
257 }
258 // ============================================================================
260 // ============================================================================
261 template <class TYPE>
262 inline PropertyWithValue<TYPE>::~PropertyWithValue()
263 {
264 Traits::dele ( m_value , m_own ) ;
265 m_value = 0 ;
266 }
267 // ============================================================================
269 // ============================================================================
270 template <class TYPE>
271 inline PropertyWithValue<TYPE>&
272 PropertyWithValue<TYPE>::operator=( const TYPE& value )
273 {
274 if ( !setValue ( value ) )
275 { throw std::out_of_range( "Value not verified" ) ; }
276 return *this ;
277 }
278 // ============================================================================
280 // ============================================================================
281 template <class TYPE>
282 inline bool
283 PropertyWithValue<TYPE>::assign ( const Property& source )
284 {
285 // 1) Is the property of "the same" type?
286 const PropertyWithValue<TYPE>* p =
287 dynamic_cast<const PropertyWithValue<TYPE>*> ( &source ) ;
288 if ( 0 != p ) { return setValue ( p->value() ) ; } // RETURN
289 // 2) Else use the string representation
290 return this->fromString( source.toString() ).isSuccess() ;
291 }
292 // ============================================================================
294 // ============================================================================
295 template <class TYPE>
296 inline bool
297 PropertyWithValue<TYPE>::load( Property& dest ) const
298 {
299 // delegate to the 'opposite' method ;
300 return dest.assign( *this ) ;
301 }
302 // ============================================================================
304 // ============================================================================
305 template <class TYPE>
306 inline std::string
307 PropertyWithValue<TYPE>::toString () const
308 {
309 useReadHandler();
310 return Gaudi::Utils::toString( *m_value ) ;
311 }
312 // ============================================================================
314 // ============================================================================
315 template <class TYPE>
316 inline void
317 PropertyWithValue<TYPE>::toStream (std::ostream& out) const
318 {
319 useReadHandler();
320 Gaudi::Utils::toStream( *m_value, out ) ;
321 }
322 // ============================================================================
324 // ============================================================================
325 template <class TYPE>
326 inline StatusCode
327 PropertyWithValue<TYPE>::fromString ( const std::string& source )
328 {
329 TYPE tmp ;
330 StatusCode sc = Gaudi::Parsers::parse ( tmp , source ) ;
331 if ( sc.isFailure() ) { return sc ; }
332 return setValue ( tmp ) ? StatusCode::SUCCESS : StatusCode::FAILURE ;
333 }
334 // ============================================================================
336 // ============================================================================
337 template <>
338 inline std::string
339 PropertyWithValue<std::string>::toString () const
340 {
341 useReadHandler();
342 return this->value() ;
343 }
344 // ============================================================================
345 template <>
346 inline bool PropertyWithValue<std::string>::assign ( const Property& source )
347 { return this->fromString( source.toString() ).isSuccess() ; }
348 // ============================================================================
349
350 // ============================================================================
352 // ============================================================================
353 template <class TYPE>
354 inline const TYPE&
355 PropertyWithValue<TYPE>::value() const
356 { useReadHandler() ; return *m_value ; }
357 // ============================================================================
358 // assignment operator
359 // ============================================================================
360 template <class TYPE>
361 PropertyWithValue<TYPE>& PropertyWithValue<TYPE>::operator=
362 ( const PropertyWithValue& right )
363 {
364 // assign the base class
365 Property::operator=( right ) ;
366 // assign the value
367 PropertyWithValue<TYPE>::operator=( right.value() ) ;
368 return *this ;
369 }
370 // ============================================================================
371 // templated assignment operator
372 // ============================================================================
373 template <class TYPE>
374 template <class OTHER>
375 PropertyWithValue<TYPE>& PropertyWithValue<TYPE>::operator=
376 ( const PropertyWithValue<OTHER>& right )
377 {
378 // assign the base class
379 Property::operator=( right ) ;
380 // assign the value
381 PropertyWithValue<TYPE>::operator=( right.value() ) ;
382 return *this ;
383 }
384 // ============================================================================
385
386 // ============================================================================
394 // ============================================================================
395 template<class TYPE,class VERIFIER>
396 class PropertyWithVerifier
397 : public PropertyWithValue<TYPE>
398 {
399 protected:
400 // ==========================================================================
402 PropertyWithVerifier
403 ( const std::string& name ,
404 typename Gaudi::Utils::PropertyTypeTraits<TYPE>::PVal value ,
405 const bool owner ,
406 const VERIFIER& verifier )
407 : PropertyWithValue<TYPE> ( name , value , owner )
408 , m_verifier ( verifier )
409 {}
411 virtual ~PropertyWithVerifier() {}
412 // ==========================================================================
413 public:
414 // ==========================================================================
415 inline VERIFIER& verifier() { return m_verifier ; }
416 inline const VERIFIER& verifier() const { return m_verifier ; }
418 bool set( const TYPE& value ) ;
420 virtual bool setValue( const TYPE& value ) { return set( value ) ; }
422 template <class OTHER,class OTHERVERIFIER>
423 PropertyWithVerifier& operator=
424 ( const PropertyWithVerifier<OTHER,OTHERVERIFIER>& right ) ;
426 template <class OTHER>
427 PropertyWithVerifier& operator=( const PropertyWithValue<OTHER>& right ) ;
429 PropertyWithVerifier& operator=( const TYPE& right ) ;
430 // ==========================================================================
431 private:
432 // ==========================================================================
434 PropertyWithVerifier() ;
436 PropertyWithVerifier( const PropertyWithVerifier& right );
437 // ==========================================================================
438 private:
439 // ==========================================================================
441 VERIFIER m_verifier ; // the verifier itself
442 // ==========================================================================
443 } ;
444 // ============================================================================
446 // ============================================================================
447 template <class TYPE,class VERIFIER>
448 inline bool
449 PropertyWithVerifier<TYPE,VERIFIER>::set( const TYPE& value )
450 {
452 if ( !m_verifier.isValid( &value ) ) { return false ; }
454 this->i_set( value ) ;
456 return this->useUpdateHandler() ;
457 }
458 // ============================================================================
460 // ============================================================================
461 template <class TYPE,class VERIFIER>
462 inline PropertyWithVerifier<TYPE,VERIFIER>&
463 PropertyWithVerifier<TYPE,VERIFIER>::operator=( const TYPE& right )
464 {
465 PropertyWithValue<TYPE>::operator=( right ) ;
466 return *this ;
467 }
468 // ============================================================================
470 // ============================================================================
471 template <class TYPE,class VERIFIER>
472 template <class OTHER>
473 inline PropertyWithVerifier<TYPE,VERIFIER>&
474 PropertyWithVerifier<TYPE,VERIFIER>::operator=( const PropertyWithValue<OTHER>& right )
475 {
476 PropertyWithValue<TYPE>::operator=(right) ;
477 return *this ;
478 }
479 // ============================================================================
481 // ============================================================================
482 template <class TYPE,class VERIFIER>
483 template <class OTHER,class OTHERVERIFIER>
484 inline PropertyWithVerifier<TYPE,VERIFIER>&
485 PropertyWithVerifier<TYPE,VERIFIER>::operator=
486 ( const PropertyWithVerifier<OTHER,OTHERVERIFIER>& right )
487 {
488 PropertyWithValue<TYPE>::operator=(right) ;
489 return *this ;
490 }
491 // ============================================================================
492
493 // ============================================================================
503 // ============================================================================
504 template <class TYPE,class VERIFIER = BoundedVerifier<TYPE> >
505 class SimpleProperty
506 : public PropertyWithVerifier<TYPE,VERIFIER>
507 {
508 protected:
509 // ==========================================================================
510 typedef Gaudi::Utils::PropertyTypeTraits<TYPE> Traits ;
511 // ==========================================================================
512 public:
513 // ==========================================================================
515 SimpleProperty
516 ( VERIFIER verifier = VERIFIER() ) ;
518 SimpleProperty
519 ( const TYPE& value ,
520 VERIFIER verifier = VERIFIER() ) ;
522 SimpleProperty
523 ( const std::string& name ,
524 const TYPE& value ,
525 VERIFIER verifier = VERIFIER() ) ;
527 template <class OTHER>
528 SimpleProperty ( const PropertyWithValue<OTHER>& right ) ;
530 SimpleProperty ( const SimpleProperty& right ) ;
532 virtual ~SimpleProperty() ;
534 virtual SimpleProperty* clone() const ;
536 SimpleProperty& operator=( const TYPE& value ) ;
538 template <class OTHER>
539 SimpleProperty& operator=( const PropertyWithValue<OTHER>& right ) ;
540 // ==========================================================================
541 };
542 // ============================================================================
544 // ============================================================================
545 template <class TYPE,class VERIFIER>
546 SimpleProperty<TYPE,VERIFIER>::SimpleProperty
547 ( VERIFIER verifier )
548 : PropertyWithVerifier<TYPE,VERIFIER>
549 ( "" , Traits::new_() , true , verifier )
550 {}
551 // ============================================================================
553 // ============================================================================
554 template <class TYPE,class VERIFIER>
555 SimpleProperty<TYPE,VERIFIER>::SimpleProperty
556 ( const TYPE& value ,
557 VERIFIER verifier )
558 : PropertyWithVerifier<TYPE,VERIFIER>
559 ( "" , Traits::new_(value) , true , verifier )
560 {}
561 // ============================================================================
563 // ============================================================================
564 template <class TYPE,class VERIFIER>
565 SimpleProperty<TYPE,VERIFIER>::SimpleProperty
566 ( const std::string& name ,
567 const TYPE& value ,
568 VERIFIER verifier )
569 : PropertyWithVerifier<TYPE,VERIFIER>
570 ( name , Traits::new_(value) , true , verifier )
571 {}
572 // ============================================================================
574 // ============================================================================
575 template <class TYPE,class VERIFIER>
576 template <class OTHER>
577 SimpleProperty<TYPE,VERIFIER>::SimpleProperty
578 ( const PropertyWithValue<OTHER>& right )
579 : PropertyWithVerifier<TYPE,VERIFIER>
580 ( right.name() , Traits::new_( right.value() ) , true , VERIFIER() )
581 {}
582 // ============================================================================
584 // ============================================================================
585 template <class TYPE,class VERIFIER>
586 SimpleProperty<TYPE,VERIFIER>::SimpleProperty
587 ( const SimpleProperty& right )
588 : PropertyWithVerifier<TYPE,VERIFIER>
589 ( right.name() , Traits::new_( right.value() ) , true , right.verifier() )
590 {}
591 // ============================================================================
593 // ============================================================================
594 template <class TYPE,class VERIFIER>
595 SimpleProperty<TYPE,VERIFIER>::~SimpleProperty(){}
596 // ============================================================================
598 // ============================================================================
599 template <class TYPE,class VERIFIER>
600 inline
601 SimpleProperty<TYPE,VERIFIER>*
602 SimpleProperty<TYPE,VERIFIER>::clone() const
603 { return new SimpleProperty(*this) ; }
604 // ============================================================================
606 // ============================================================================
607 template <class TYPE,class VERIFIER>
608 inline
609 SimpleProperty<TYPE,VERIFIER>&
610 SimpleProperty<TYPE,VERIFIER>::operator=( const TYPE& value )
611 {
612 PropertyWithVerifier<TYPE,VERIFIER>::operator=( value );
613 return *this ;
614 }
615 // ============================================================================
617 // ============================================================================
618 template <class TYPE,class VERIFIER>
619 template <class OTHER>
620 inline
621 SimpleProperty<TYPE,VERIFIER>&
622 SimpleProperty<TYPE,VERIFIER>::operator=
623 ( const PropertyWithValue<OTHER>& right )
624 {
625 PropertyWithVerifier<TYPE,VERIFIER>::operator=( right );
626 return *this ;
627 }
628 // ============================================================================
629
630 // ============================================================================
639 // ============================================================================
640 template< class TYPE, class VERIFIER = NullVerifier<TYPE> >
641 class SimplePropertyRef :
642 public PropertyWithVerifier<TYPE,VERIFIER>
643 {
644 public:
646 SimplePropertyRef
647 ( const std::string& name ,
648 TYPE& value ,
649 VERIFIER verifier = VERIFIER() ) ;
651 SimplePropertyRef ( const SimplePropertyRef& right ) ;
653 virtual ~SimplePropertyRef() ;
655 virtual SimplePropertyRef* clone() const ;
657 SimplePropertyRef& operator=( const TYPE& value ) ;
659 template <class OTHER>
660 SimplePropertyRef& operator=( const PropertyWithValue<OTHER>& right ) ;
661 private:
662 // the default constructor is disabled
663 SimplePropertyRef() ;
664 };
665 // ============================================================================
667 // ============================================================================
668 template <class TYPE,class VERIFIER>
669 SimplePropertyRef<TYPE,VERIFIER>::SimplePropertyRef
670 ( const std::string& name ,
671 TYPE& value ,
672 VERIFIER verifier )
673 : PropertyWithVerifier<TYPE,VERIFIER> ( name , &value , false , verifier )
674 {}
675 // ============================================================================
677 // ============================================================================
678 template <class TYPE,class VERIFIER>
679 SimplePropertyRef<TYPE,VERIFIER>::SimplePropertyRef
680 ( const SimplePropertyRef& right )
681 : PropertyWithVerifier<TYPE,VERIFIER>
682 ( right.name() , right.i_get() , false , right.verifier() )
683 {}
684 // ============================================================================
686 // ============================================================================
687 template <class TYPE,class VERIFIER>
688 SimplePropertyRef<TYPE,VERIFIER>::~SimplePropertyRef(){}
689 // ============================================================================
691 // ============================================================================
692 template <class TYPE,class VERIFIER>
693 inline
694 SimplePropertyRef<TYPE,VERIFIER>*
695 SimplePropertyRef<TYPE,VERIFIER>::clone() const
696 { return new SimplePropertyRef(*this) ; }
697 // ============================================================================
699 // ============================================================================
700 template <class TYPE,class VERIFIER>
701 inline
702 SimplePropertyRef<TYPE,VERIFIER>&
703 SimplePropertyRef<TYPE,VERIFIER>::operator=( const TYPE& value )
704 {
705 PropertyWithVerifier<TYPE,VERIFIER>::operator=( value ) ;
706 return *this ;
707 }
708 // ============================================================================
710 // ============================================================================
711 template <class TYPE,class VERIFIER>
712 template <class OTHER>
713 inline
714 SimplePropertyRef<TYPE,VERIFIER>&
715 SimplePropertyRef<TYPE,VERIFIER>::operator=
716 ( const PropertyWithValue<OTHER>& right )
717 {
718 PropertyWithVerifier<TYPE,VERIFIER>::operator=( right );
719 return *this ;
720 }
721 // ============================================================================
722
723
724
725
726 // Typedef Properties for built-in types
727 typedef SimpleProperty< bool > BooleanProperty;
728 typedef SimpleProperty< char > CharProperty;
729 typedef SimpleProperty< signed char > SignedCharProperty;
730 typedef SimpleProperty< unsigned char > UnsignedCharProperty;
731 typedef SimpleProperty< short > ShortProperty;
732 typedef SimpleProperty< unsigned short > UnsignedShortProperty;
733 typedef SimpleProperty< int > IntegerProperty;
734 typedef SimpleProperty< unsigned int > UnsignedIntegerProperty;
735 typedef SimpleProperty< long > LongProperty;
736 typedef SimpleProperty< unsigned long > UnsignedLongProperty;
737 typedef SimpleProperty< long long> LongLongProperty;
738 typedef SimpleProperty< unsigned long long> UnsignedLongLongProperty;
739 typedef SimpleProperty< float > FloatProperty;
740 typedef SimpleProperty< double > DoubleProperty;
741 typedef SimpleProperty< long double > LongDoubleProperty;
742
743 typedef SimpleProperty< std::string > StringProperty;
744
745
746 // Typedef PropertyRefs for built-in types
747 typedef SimplePropertyRef< bool > BooleanPropertyRef;
748 typedef SimplePropertyRef< char > CharPropertyRef;
749 typedef SimplePropertyRef< signed char > SignedCharPropertyRef;
750 typedef SimplePropertyRef< unsigned char > UnsignedCharPropertyRef;
751 typedef SimplePropertyRef< short > ShortPropertyRef;
752 typedef SimplePropertyRef< unsigned short > UnsignedShortPropertyRef;
753 typedef SimplePropertyRef< int > IntegerPropertyRef;
754 typedef SimplePropertyRef< unsigned int > UnsignedIntegerPropertyRef;
755 typedef SimplePropertyRef< long > LongPropertyRef;
756 typedef SimplePropertyRef< unsigned long > UnsignedLongPropertyRef;
757 typedef SimplePropertyRef< long long > LongLongPropertyRef;
758 typedef SimplePropertyRef< unsigned long long > UnsignedLongLongPropertyRef;
759 typedef SimplePropertyRef< float > FloatPropertyRef;
760 typedef SimplePropertyRef< double > DoublePropertyRef;
761 typedef SimplePropertyRef< long double > LongDoublePropertyRef;
762
763 typedef SimplePropertyRef< std::string > StringPropertyRef;
764
765
766 // Typedef "Arrays" of Properties for built-in types
767 typedef SimpleProperty< std::vector< bool > > BooleanArrayProperty;
768 typedef SimpleProperty< std::vector< char > > CharArrayProperty;
769 typedef SimpleProperty< std::vector< signed char > > SignedCharArrayProperty;
770 typedef SimpleProperty< std::vector< unsigned char > > UnsignedCharArrayProperty;
771 typedef SimpleProperty< std::vector< short > > ShortArrayProperty;
772 typedef SimpleProperty< std::vector< unsigned short > > UnsignedShortArrayProperty;
773 typedef SimpleProperty< std::vector< int > > IntegerArrayProperty;
774 typedef SimpleProperty< std::vector< unsigned int > > UnsignedIntegerArrayProperty;
775 typedef SimpleProperty< std::vector< long > > LongArrayProperty;
776 typedef SimpleProperty< std::vector< unsigned long > > UnsignedLongArrayProperty;
777 typedef SimpleProperty< std::vector< long long > > LongLongArrayProperty;
778 typedef SimpleProperty< std::vector< unsigned long long > > UnsignedLongLongArrayProperty;
779 typedef SimpleProperty< std::vector< float > > FloatArrayProperty;
780 typedef SimpleProperty< std::vector< double > > DoubleArrayProperty;
781 typedef SimpleProperty< std::vector< long double > > LongDoubleArrayProperty;
782
783 typedef SimpleProperty< std::vector< std::string > > StringArrayProperty;
784
785
786 // Typedef "Arrays" of PropertyRefs for built-in types
787 typedef SimplePropertyRef< std::vector< bool > > BooleanArrayPropertyRef;
788 typedef SimplePropertyRef< std::vector< char > > CharArrayPropertyRef;
789 typedef SimplePropertyRef< std::vector< signed char > > SignedCharArrayPropertyRef;
790 typedef SimplePropertyRef< std::vector< unsigned char > > UnsignedCharArrayPropertyRef;
791 typedef SimplePropertyRef< std::vector< short > > ShortArrayPropertyRef;
792 typedef SimplePropertyRef< std::vector< unsigned short > > UnsignedShortArrayPropertyRef;
793 typedef SimplePropertyRef< std::vector< int > > IntegerArrayPropertyRef;
794 typedef SimplePropertyRef< std::vector< unsigned int > > UnsignedIntegerArrayPropertyRef;
795 typedef SimplePropertyRef< std::vector< long > > LongArrayPropertyRef;
796 typedef SimplePropertyRef< std::vector< unsigned long > > UnsignedLongArrayPropertyRef;
797 typedef SimplePropertyRef< std::vector< long long > > LongLongArrayPropertyRef;
798 typedef SimplePropertyRef< std::vector< unsigned long long > > UnsignedLongLongArrayPropertyRef;
799 typedef SimplePropertyRef< std::vector< float > > FloatArrayPropertyRef;
800 typedef SimplePropertyRef< std::vector< double > > DoubleArrayPropertyRef;
801 typedef SimplePropertyRef< std::vector< long double > > LongDoubleArrayPropertyRef;
802
803 typedef SimplePropertyRef< std::vector< std::string > > StringArrayPropertyRef;
804
805 // pre-declaration is sufficient here
806 class GaudiHandleBase;
807
808 class GAUDI_API GaudiHandleProperty : public Property {
809 public:
810 GaudiHandleProperty( const std::string& name, GaudiHandleBase& ref );
811
812 GaudiHandleProperty& operator=( const GaudiHandleBase& value );
813
814 virtual GaudiHandleProperty* clone() const;
815
816 virtual bool load( Property& destination ) const;
817
818 virtual bool assign( const Property& source );
819
820 virtual std::string toString() const;
821
822 virtual void toStream(std::ostream& out) const;
823
824 virtual StatusCode fromString(const std::string& s);
825
826 const GaudiHandleBase& value() const;
827
828 bool setValue( const GaudiHandleBase& value );
829
830 private:
833 GaudiHandleBase* m_pValue;
834 };
835
836 // implementation in header file only where the GaudiHandleBase class
837 // definition is not needed. The rest goes into the .cpp file.
838 // The goal is to decouple the header files, to avoid that the whole
839 // world depends on GaudiHandle.h
840 inline GaudiHandleProperty& GaudiHandleProperty::operator=( const GaudiHandleBase& value ) {
841 setValue( value );
842 return *this;
843 }
844
845 inline GaudiHandleProperty* GaudiHandleProperty::clone() const {
846 return new GaudiHandleProperty( *this );
847 }
848
849 inline bool GaudiHandleProperty::load( Property& destination ) const {
850 return destination.assign( *this );
851 }
852
853 inline bool GaudiHandleProperty::assign( const Property& source ) {
854 return fromString( source.toString() ).isSuccess();
855 }
856
857 inline const GaudiHandleBase& GaudiHandleProperty::value() const {
858 useReadHandler();
859 return *m_pValue;
860 }
861
862
863 // pre-declaration is sufficient here
864 class GaudiHandleArrayBase;
865
866 class GAUDI_API GaudiHandleArrayProperty : public Property {
867 public:
868
869 GaudiHandleArrayProperty( const std::string& name, GaudiHandleArrayBase& ref );
870
871 GaudiHandleArrayProperty& operator=( const GaudiHandleArrayBase& value );
872
873 virtual GaudiHandleArrayProperty* clone() const;
874
875 virtual bool load( Property& destination ) const;
876
877 virtual bool assign( const Property& source );
878
879 virtual std::string toString() const;
880
881 virtual void toStream(std::ostream& out) const;
882
883 virtual StatusCode fromString(const std::string& s);
884
885 const GaudiHandleArrayBase& value() const;
886
887 bool setValue( const GaudiHandleArrayBase& value );
888
889 private:
892 GaudiHandleArrayBase* m_pValue;
893
894 };
895
896 // implementation in header file only where the GaudiHandleBase class
897 // definition is not needed. The rest goes into the .cpp file.
898 // The goal is to decouple the header files, to avoid that the whole
899 // world depends on GaudiHandle.h
900 inline GaudiHandleArrayProperty& GaudiHandleArrayProperty::operator=( const GaudiHandleArrayBase& value ) {
901 setValue( value );
902 return *this;
903 }
904
905 inline GaudiHandleArrayProperty* GaudiHandleArrayProperty::clone() const {
906 return new GaudiHandleArrayProperty( *this );
907 }
908
909 inline bool GaudiHandleArrayProperty::load( Property& destination ) const {
910 return destination.assign( *this );
911 }
912
913 inline bool GaudiHandleArrayProperty::assign( const Property& source ) {
914 return fromString( source.toString() ) != 0;
915 }
916
917 inline const GaudiHandleArrayBase& GaudiHandleArrayProperty::value() const {
918 useReadHandler();
919 return *m_pValue;
920 }
921
922
923 namespace Gaudi
924 {
925 namespace Utils
926 {
927 // ========================================================================
945 GAUDI_API bool hasProperty ( const IProperty* p , const std::string& name ) ;
946 // ========================================================================
964 GAUDI_API bool hasProperty ( const IInterface* p , const std::string& name ) ;
965 // ========================================================================
983 GAUDI_API Property* getProperty
984 ( const IProperty* p , const std::string& name ) ;
985 // ========================================================================
1003 GAUDI_API Property* getProperty
1004 ( const IInterface* p , const std::string& name ) ;
1005 // ========================================================================
1028 GAUDI_API bool hasProperty
1029 ( const std::vector<const Property*>* p ,
1030 const std::string& name ) ;
1031 // ========================================================================
1054 GAUDI_API const Property* getProperty
1055 ( const std::vector<const Property*>* p ,
1056 const std::string& name ) ;
1057 // ========================================================================
1081 template <class TYPE>
1082 StatusCode setProperty
1083 ( IProperty* component ,
1084 const std::string& name ,
1085 const TYPE& value ,
1086 const std::string& doc ) ;
1087 // ========================================================================
1110 template <class TYPE>
1111 StatusCode setProperty
1112 ( IProperty* component ,
1113 const std::string& name ,
1114 const TYPE& value )
1115 { return setProperty ( component , name , value , std::string() ) ; }
1116 // ========================================================================
1130 GAUDI_API StatusCode setProperty
1131 ( IProperty* component ,
1132 const std::string& name ,
1133 const std::string& value ,
1134 const std::string& doc = "" ) ;
1135 // ========================================================================
1149 GAUDI_API StatusCode setProperty
1150 ( IProperty* component ,
1151 const std::string& name ,
1152 const char* value ,
1153 const std::string& doc = "" ) ;
1154 // ========================================================================
1168 template <unsigned N>
1169 StatusCode setProperty
1170 ( IProperty* component ,
1171 const std::string& name ,
1172 const char (&value)[N] ,
1173 const std::string& doc = "" )
1174 {
1175 if ( 0 == component ) { return StatusCode::FAILURE ; }
1176 const std::string val = std::string ( value , value + N ) ;
1177 return setProperty ( component , name , val , doc ) ;
1178 }
1179 // ========================================================================
1210 template <class TYPE>
1211 StatusCode setProperty
1212 ( IProperty* component ,
1213 const std::string& name ,
1214 const TYPE& value ,
1215 const std::string& doc )
1216 {
1217 if ( 0 == component ) { return StatusCode::FAILURE ; } // RETURN
1218 if ( !hasProperty ( component , name ) ) { return StatusCode::FAILURE ; }
1219 const std::string val = Gaudi::Utils::toString ( value ) ;
1220 return Gaudi::Utils::setProperty ( component , name , val , doc ) ;
1221 }
1222 // ========================================================================
1244 GAUDI_API StatusCode setProperty
1245 ( IProperty* component ,
1246 const std::string& name ,
1247 const Property* property ,
1248 const std::string& doc = "" ) ;
1249 // ========================================================================
1271 GAUDI_API StatusCode setProperty
1272 ( IProperty* component ,
1273 const std::string& name ,
1274 const Property& property ,
1275 const std::string& doc = "" ) ;
1276 // ========================================================================
1299 template <class TYPE>
1300 StatusCode setProperty
1301 ( IProperty* component ,
1302 const std::string& name ,
1303 const SimpleProperty<TYPE>& value ,
1304 const std::string& doc = "" )
1305 {
1306 const Property* property = &value ;
1307 return setProperty ( component , name , property , doc ) ;
1308 }
1309 // ========================================================================
1330 template <class TYPE>
1331 StatusCode setProperty
1332 ( IInterface* component ,
1333 const std::string& name ,
1334 const TYPE& value ,
1335 const std::string& doc = "" )
1336 {
1337 if ( 0 == component ) { return StatusCode::FAILURE ; }
1338 SmartIF<IProperty> property ( component ) ;
1339 if ( !property ) { return StatusCode::FAILURE ; }
1340 return setProperty ( property , name , value , doc ) ;
1341 }
1342 // ========================================================================
1355 GAUDI_API StatusCode setProperty
1356 ( IInterface* component ,
1357 const std::string& name ,
1358 const std::string& value ,
1359 const std::string& doc = "" ) ;
1360 // ========================================================================
1373 GAUDI_API StatusCode setProperty
1374 ( IInterface* component ,
1375 const std::string& name ,
1376 const char* value ,
1377 const std::string& doc = "" ) ;
1378 // ========================================================================
1392 template <unsigned N>
1393 StatusCode setProperty
1394 ( IInterface* component ,
1395 const std::string& name ,
1396 const char (&value)[N] ,
1397 const std::string& doc = "" )
1398 {
1399 if ( 0 == component ) { return StatusCode::FAILURE ; }
1400 const std::string val = std::string ( value , value + N ) ;
1401 return setProperty ( component , name , val , doc ) ;
1402 }
1403 // ========================================================================
1425 GAUDI_API StatusCode setProperty
1426 ( IInterface* component ,
1427 const std::string& name ,
1428 const Property* property ,
1429 const std::string& doc = "" ) ;
1430 // ========================================================================
1452 GAUDI_API StatusCode setProperty
1453 ( IInterface* component ,
1454 const std::string& name ,
1455 const Property& property ,
1456 const std::string& doc = "" ) ;
1457 // ========================================================================
1480 template <class TYPE>
1481 StatusCode
1482 setProperty
1483 ( IInterface* component ,
1484 const std::string& name ,
1485 const SimpleProperty<TYPE>& value ,
1486 const std::string& doc = "" )
1487 {
1488 const Property* property = &value ;
1489 return setProperty ( component , name , property , doc ) ;
1490 }
1491 // ========================================================================
1492 } // end of namespace Gaudi::Utils
1493 } // end of namespace Gaudi
1494
1495
1496 // ============================================================================
1497 // The END
1498 // ============================================================================
1499 #endif // GAUDIKERNEL_PROPERTY_H
1500 // ============================================================================