modernization of Property

This is a major rewrite of the system of Property classes. Started as the implementation of GAUDI-1214, it continued as a review of IProperty and PropertyMgr, to end up in a complete rewrite (and optimization) of PropertyWithValue.

• Fixes GAUDI-1214
  • added missing declareProperty signature
  • added PropertyHolder (an updated PropertyMgr)
  • adapted all properties in Gaudi
• improved use of PropertyHolder
  • use inheritance instead of composition
  • removed ~200 (duplicated) lines of code in GaudiKernel
• optimization of Property (fixes GAUDI-1229)
  • use templates and automatic code generation to handle efficiently both value and reference properties
    • avoid creation of values on the heap (see GAUDI-1229)
    • removed the owned boolean flag
    • improved usability of properties (e.g. begin/end wrappers for C++11 loops, increment/decrement operators...)
    • deprecated use of C arrays as properties
  • merged features of PropertyWithVerifier, SimpleProperty and SimplePropertyRef into PropertyWithValue
  • deduplication of name and doc strings via boost::string_ref and a static storage (see GAUDI-1229)
• Fixes GAUDI-1205
• added deprecation warnings in service accessors of Algorithm (@graven)
• renamed Property base class to Gaudi::Details::PropertyBase and PropertyWithValue to Gaudi::Property
  • added backward compatibility type aliases (but not compatible with forward declarations of class Property, which should be replaced by #include "GaudiKernel/PropertyFwd.h")
• added macro GAUDI_PROPERTY_v2 to allow easy implementation of backward compatible changes in derived projects (e.g. when user code relied on DoubleProperty having a verifier)
• Fixes GAUDI-1268

The changes are as backward compatible as much as possible (except if you explicitly inherit from SimpleProperty, or you forward declared class Property, which now are typedefs), but must be validated in the experiment frameworks.

GaudiKernel/GaudiKernel/Property.h

@@ -406,15 +406,15 @@ public:
   {
     return value().end();
   }
-  template <class T = const ValueType>
-  inline decltype( std::declval<T>()[typename T::key_type{}] ) operator[]( const typename T::key_type& key ) const
+  template <class ARG, class T = const ValueType>
+  inline decltype( std::declval<T>()[ARG{}] ) operator[]( const ARG& arg ) const
   {
-    return value()[key];
+    return value()[arg];
   }
-  template <class T = ValueType>
-  inline decltype( std::declval<T>()[typename T::key_type{}] ) operator[]( const typename T::key_type& key )
+  template <class ARG, class T = ValueType>
+  inline decltype( std::declval<T>()[ARG{}] ) operator[]( const ARG& arg )
   {
-    return value()[key];
+    return value()[arg];
   }
   template <class T = const ValueType>
   inline decltype( std::declval<T>().find(typename T::key_type{}) ) find( const typename T::key_type& key ) const