TProperty.icc

Go to the documentation of this file.

/*
  Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef ASGTOOLS_TPROPERTY_ICC
#define ASGTOOLS_TPROPERTY_ICC
 
#include <AsgTools/MessageCheckAsgTools.h>
#include <map>
#include <sstream>
#include <typeinfo>
#include <type_traits>
 
namespace asg
{
  namespace detail
  {
    /// \brief pack a single string into a property string
    StatusCode packStringSingle (const std::string& value,
                 std::string& result);
 
    /// \brief pack a vector of strings into a property string
    StatusCode packStringVector (const std::vector<std::string>& value,
                 std::string& result);
 
    /// \brief pack a vector of strings into a property string
    StatusCode packStringMap (const std::map<std::string,std::string>& value,
                              std::string& result);
 
    /// \brief unpack a single string from a property string
    StatusCode unpackStringSingle (const std::string& value,
                   std::string& result);
 
    /// \brief unpack a vector of strings from a property string
    StatusCode unpackStringVector (const std::string& value,
                   std::vector<std::string>& result);
 
    /// \brief unpack a vector of strings from a property string
    StatusCode unpackStringMap (const std::string& value,
                                std::map<std::string,std::string>& result);
 
    /// \brief check for the existence of an output streamer
    template <typename T>
    class HasOStreamer
    {
      typedef char one;
      typedef long two;
 
      template <typename C> static one test( decltype(&(*(std::ostream*)0 << *(C*)0)));
      template <typename C> static two test(...);    
 
    public:
      enum { value = sizeof(test<T>(0)) == sizeof(char) };
    };
 
    /// \brief check for the existence of conversion to string
    template <typename T>
    class HasOStringConvert
    {
      typedef char one;
      typedef long two;
 
      template <typename C> static one test( decltype((std::string (*(C*)0)))*);
      template <typename C> static two test(...);    
 
    public:
      enum { value = sizeof(test<T>(0)) == sizeof(char) };
    };
 
 
    /// \brief base class for getting the string content using
    /// streamers/default conversions
    template<typename T,
         bool hasOStreamer = HasOStreamer<T>::value,
         bool hasOConvert = HasOStringConvert<T>::value>
    struct GetStringHelperBase
    {
      static StatusCode get (const T& /*value*/, std::string& /*result*/) {
    using namespace msgProperty;
    ANA_MSG_ERROR ("GetStringHelper: not implemented for " << typeid (T).name());
    return StatusCode::FAILURE;
      }
    };
 
    template<typename T> struct GetStringHelperBase<T,true,false>
    {
      static StatusCode get (const T& value, std::string& result) {
    using namespace msgProperty;
    std::ostringstream str;
    if (str << value)
    {
      result = str.str();
      return StatusCode::SUCCESS;
    } else
    {
      ANA_MSG_ERROR ("failed to write type " << typeid(T).name() << " to string");
      return StatusCode::FAILURE;
    }
      }
    };
 
    template<typename T,bool X> struct GetStringHelperBase<T,X,true>
    {
      static StatusCode get (const T& value, std::string& result) {
        return packStringSingle (std::string (value), result);
      }
    };
 
    /// \brief helper class for converting properties to strings
    template<typename T> struct GetStringHelper : GetStringHelperBase<T>
    {
    };
 
    template<typename T> struct GetStringHelper<std::vector<T> >
    {
      static StatusCode get (const std::vector<T>& value,
                 std::string& result) {
    using namespace msgProperty;
    std::vector<std::string> subresult;
    for (const auto& subvalue : value) {
      std::string myresult;
      ANA_CHECK (GetStringHelper<T>::get (subvalue, myresult));
      subresult.push_back (myresult);
    }
    ANA_CHECK (packStringVector (subresult, result));
    return StatusCode::SUCCESS;
      }
    };
 
    template<typename T1,typename T2> struct GetStringHelper<std::map<T1,T2> >
    {
      static StatusCode get (const std::map<T1,T2>& value,
                 std::string& result) {
    using namespace msgProperty;
    std::map<std::string,std::string> subresult;
    for (const auto& subvalue : value) {
      std::string myresult1, myresult2;
      ANA_CHECK (GetStringHelper<T1>::get (subvalue.first, myresult1));
      ANA_CHECK (GetStringHelper<T2>::get (subvalue.second, myresult2));
      subresult.emplace (myresult1, myresult2);
    }
    ANA_CHECK (packStringMap (subresult, result));
    return StatusCode::SUCCESS;
      }
    };
 
 
 
    /// \brief the template overloads for \ref TProperty::getCastString
    template <typename T>
    struct GetCastStringHelper
    {
      static inline StatusCode get (const T& value, std::string& result) {
        return GetStringHelper<T>::get (value, result);}
    };
 
    template <>
    struct GetCastStringHelper<std::string>
    {
      static inline StatusCode get (const std::string& value, std::string& result) {
        result = value; return StatusCode::SUCCESS;}
    };
 
 
 
 
    /// \brief check for the existence of an output streamer
    template <typename T>
    class HasIStreamer
    {
      typedef char one;
      typedef long two;
 
      template <typename C> static one test( decltype(&(*(std::istream*)0 >> *(C*)0)));
      template <typename C> static two test(...);    
 
    public:
      enum { value = sizeof(test<T>(0)) == sizeof(char) };
    };
 
    /// \brief check for the existence of conversion to string
    template <typename T>
    class HasIStringConvert
    {
      typedef char one;
      typedef long two;
 
      template <typename C> static one test( decltype(C (std::string ()))*);
      template <typename C> static two test(...);    
 
    public:
      enum { value = sizeof(test<T>(0)) == sizeof(char) };
    };
 
 
    /// \brief base class for setting the string content using
    /// streamers/default conversions
    template<typename T,
         bool hasIStreamer = HasIStreamer<T>::value,
         bool hasOConvert = HasIStringConvert<T>::value,
             bool isEnum = std::is_enum<T>::value>
    struct SetStringHelperBase
    {
      static StatusCode set (const std::string& /*value*/, T& /*result*/) {
    using namespace msgProperty;
    ANA_MSG_ERROR ("SetStringHelper: not implemented for " << typeid (T).name());
    return StatusCode::FAILURE;
      }
    };
 
    template<typename T> struct SetStringHelperBase<T,true,false,false>
    {
      static StatusCode set (const std::string& value, T& result) {
    using namespace msgProperty;
    std::istringstream str (value);
    if (str >> result && str.eof())
    {
      return StatusCode::SUCCESS;
    } else
    {
      ANA_MSG_ERROR ("failed to read type " << typeid(T).name() << " from string " << value);
      return StatusCode::FAILURE;
    }
      }
    };
 
    template<typename T,bool X> struct SetStringHelperBase<T,X,true,false>
    {
      static StatusCode set (const std::string& value, T& result) {
    using namespace msgProperty;
        std::string subvalue;
        if (unpackStringSingle (value, subvalue).isFailure())
          return StatusCode::FAILURE;
        result = subvalue;
        return StatusCode::SUCCESS;
      }
    };
 
    template<typename T,bool X,bool Y> struct SetStringHelperBase<T,X,Y,true>
    {
      static StatusCode set (const std::string& value, T& result) {
    using namespace msgProperty;
        int subvalue = 0;
        if (SetStringHelperBase<int>::set (value, subvalue).isFailure())
          return StatusCode::FAILURE;
        result = T (subvalue);
        return StatusCode::SUCCESS;
      }
    };
 
    /// \brief helper class for getting property values from strings
    // cppcheck-suppress syntaxError
    template<typename T> struct SetStringHelper : SetStringHelperBase<T>
    {
    };
 
    template<typename T> struct SetStringHelper<std::vector<T> >
    {
      static StatusCode set (const std::string& value, std::vector<T>& result) {
    using namespace msgProperty;
    std::vector<std::string> myvalue;
    ANA_CHECK (unpackStringVector (value, myvalue));
    std::vector<T> myresult;
    for (const std::string& subvalue : myvalue) {
      T subresult {};
      ANA_CHECK (SetStringHelper<T>::set (subvalue, subresult));
      myresult.push_back (subresult);
    }
    swap (myresult, result);
    return StatusCode::SUCCESS;
      }
    };
 
    template<typename T1,typename T2> struct SetStringHelper<std::map<T1,T2> >
    {
      static StatusCode set (const std::string& value, std::map<T1,T2>& result) {
    using namespace msgProperty;
    std::map<std::string,std::string> myvalue;
    ANA_CHECK (unpackStringMap (value, myvalue));
    std::map<T1,T2> myresult;
    for (const auto& subvalue : myvalue) {
      T1 subresult1 {};
      T2 subresult2 {};
      ANA_CHECK (SetStringHelper<T1>::set (subvalue.first, subresult1));
      ANA_CHECK (SetStringHelper<T2>::set (subvalue.second, subresult2));
      myresult.emplace (subresult1, subresult2);
    }
    swap (myresult, result);
    return StatusCode::SUCCESS;
      }
    };
  }
}
 
template< typename T >
TProperty< T >::TProperty( T& val, Type type )
   : Property( type ), m_ptr( &val ) {
 
}
 
template< typename T >
const T* TProperty< T >::pointer() const {
 
   return m_ptr;
}
 
template< typename T >
int TProperty< T >::setFrom( const Property& rhs ) {
 
   // Check that we have a valid pointer:
   if( ! this->pointer() ) {
      return 1;
   }
 
   // Check if the other object is of the same type:
   const TProperty< T >* pprop = dynamic_cast< const TProperty< T >* >( &rhs );
   if( pprop ) {
     // Check that the other object has a valid pointer:
     if( ! pprop->pointer() ) {
       return 1;
     }
 
     // Do the assignment:
     *m_ptr = *( pprop->pointer() );
     return 0;
   } else {
     std::string asString;
     if (rhs.getCastString (asString).isFailure())
       return 1;
     return this->setString (asString).isFailure();
   }
}
 
template< typename T >
StatusCode TProperty< T >::getString (std::string& result) const {
  using namespace asg::msgProperty;
  if( ! this->pointer() ) {
    ANA_MSG_ERROR ("property does not have a pointer associated");
    return StatusCode::FAILURE;
  }
  ANA_CHECK (asg::detail::GetStringHelper<T>::get (*m_ptr, result));
  return StatusCode::SUCCESS;
}
 
template< typename T >
StatusCode TProperty< T >::getCastString (std::string& result) const {
  using namespace asg::msgProperty;
  if( ! this->pointer() ) {
    ANA_MSG_ERROR ("property does not have a pointer associated");
    return StatusCode::FAILURE;
  }
  ANA_CHECK (asg::detail::GetCastStringHelper<T>::get (*m_ptr, result));
  return StatusCode::SUCCESS;
}
 
template< typename T >
StatusCode TProperty< T >::setString (const std::string& value) {
  using namespace asg::msgProperty;
  if( ! this->pointer() ) {
    ANA_MSG_ERROR ("property does not have a pointer associated");
    return StatusCode::FAILURE;
  }
  ANA_CHECK (asg::detail::SetStringHelper<T>::set (value, *m_ptr));
  return StatusCode::SUCCESS;
}
 
template< typename T >
Property* createProperty( const T& rval ) {
 
   return new TProperty< T >( const_cast< T& >( rval ), Property::UNKNOWNTYPE );
}
 
#endif // ASGTOOLS_TPROPERTY_ICC