- replace trivial destructor with = default
   - avoid comparing pointer to 0
   - simplify constructors
   = qualify implementations with 'override' instead of 'virtual'

   - pass sink arguments by value and std::move them im place
   - do not qualify by-value returned objects as const
   - prefer nullptr over 0
   - qualify implementations with 'override' instead of 'virtual'
   - prefer STL algorithms over raw loops
   - avoid 'if' statements in loops

  - simplify code
  - prefer std::equal_range over std::lower_bound and std::upper_bound

   - pass sink arguments by value, and std::move them
   - simplify constructors
   - flag trivial destructors as = default
   - prefer nullptr over 0

   - qualify implementation with 'override' instead of 'virtual'
   - pass sink arguments by value and std::move them
   - flag not implemented constructors, assignments, .. as = delete

  - the dynamic_cast problems described in GaudiKernel/doc/dynamic_cast.pb
    observed with gcc 3.2 under linux are no longer an issue for gcc 4.9...

  - qualify implementations as 'override' instead of 'virtual'
  - mark omitted constructors as '= delete'
  - use perfect forwarding in AlgFactory::create

   see https://its.cern.ch/jira/browse/GAUDI-1071 for the reason behind this.

  - replace the use of a dedicated PropertyCallBackFunctor and
    its derived classes by by std::function<void(Property&>.
  - the normal use-case, i.e. declareProperty with a pointer to some
    class, and a pointer to its member function, has been re-implemented
    by forwarding a lambda with the right signature.
  - the value semantics of this solution (compared to the pointer
    to base semanitics) make assigning, copying, initializing
    and deleting Properties a lot simpler -- so much that the dedicated
    assignment, copy, destructors can now all be replaced by '= default'.
    (long live value semantics!)
  - LHCb code required two one-line changes to deal with this (which
    have been committed, and which work both with the old and new
    setup -- just replace 'if ( p->updateCallBack() == 0 )' with
    'if ( !p->updateHandler() )' as this now returns a const std::function<void(Property&)>&
    instead of a const PropertyCallbackFunctor* -- and the former
    properly implements operator bool(). (actually, it also allows
    comparison with a nullptr_t, so one could have changed 0 into nullptr)
    For Atlas (according to LXR) there is one bit of code which
    needs <10 lines of change (but it will depend on Gaudi version),
    as it seems to temporarily removes, and then puts back the updateHandler.

   - pass sink arguments by value and std::move them
   - use single named functor over two identical std::not1(std::ptr_fun<>(...))

   - prefer emplace_back over push_back
   - pass sink arguments by value and std::move them in place

Instead, build a functor, which converts on constuction, and then use
the functors operator() inside of the loop.

Also, unify some printout code.

   - simplify constructors
   - use auto to simplify code

   - lift 'erase_if' and use it in a few places

  - qualify implementations with 'override' instead of 'virtual'
  - use auto and std::initializer_list to streamline code

  - simplify constructors
  - use variadic template and perfect forwarding in CommonMessaging constructor

   - add 'const' versions of aida2root
   - streamline implementation of aida2root
   - pass sink arguments by value and std::move them in place
   - prefer emplace_back over push_back
   - prefer STL algorithms over raw loops
   - do not have variable names that start with __
   - streamline Gaudi::Utils::Histos::{to,from}Xml

   - simplify constructors
   - qualify implementations with 'override' instead of 'virtual'
   - replace trivial destructor with = default
   - avoid invoking std::unique_ptr<T>::get when not needed