Type safe boost::property_tree equivalent

Question

I am looking for a structure that closely ressemble boost::property_tree. However it should be a little more type-safe, for instance I'd like to get an exception when I do:

#include <boost/property_tree/ptree.hpp>

int main()
{
  using boost::property_tree::ptree;
  ptree pt;
  pt.put( "key1", "1.2" ); // insert a string in key1

  std::string val1 = pt.get<std::string>( "key1" ); // ok

  double val3 = pt.get<double>( "key1" ); // ideally would throw

  return 0;
}

Basically I am looking for an implementation of case #2, as described in [34.4] How can I build a of objects of different types?. My container should allow the nested case (container of container).

Answer 1

You can try to enforce type usage by forcing data access through a Translator.

Meaning, you could create a class that wraps-around/mimics a property_tree interface, but add some additional implementation features to try to control types.

I have provided a simple of a class ptree_type_safe that mimics some of the data access interface of a property_tree (put() and get()), but only allows certain types to be retrieved. If you run the code it should print a ptree_bad_data error message when double val3 pt.get<double>("key1") is called.

#include<iostream>
#include<boost/property_tree/ptree.hpp>
#include<boost/optional.hpp>


// Wrapper class for boost::property_tree::ptree
class ptree_type_safe
{
public:
    // Constructor
    ptree_type_safe() : m_Internal_tree(boost::property_tree::ptree()) {}

    // Example function wrappers to take special measure will dealing with types
    // put()
    template<class Type>
    boost::property_tree::ptree::self_type& put(const boost::property_tree::ptree::path_type& Path, const Type& Value)
    {
        return m_Internal_tree.put(Path, Value);
    }
    // get()
    template<class Type>
    Type get(const boost::property_tree::ptree::path_type& Path)
    {
        return m_Internal_tree.get<Type>(Path, force_type<Type>());
    }

private:
    boost::property_tree::ptree m_Internal_tree; // ptree

    // force_type is a Translator that can be used to convert types
    // and in this case, enforce calls to get() of only allowed types
    template<typename T>
    struct force_type
    {
        typedef std::string internal_type;
        typedef T external_type;
        boost::optional<T> get_value(const std::string& Key)
        {
            // This function will return the result of return_value<T>() if T is an allowed
            // type, that is T has explicit specialization for struct is_allowed_type<T>
            // and T has explicit specialization for the function return_value<T>().
            return boost::make_optional(is_allowed_type<T>::value, return_value<T>(Key));
        }
        template<typename Arg_type>
        struct is_allowed_type : std::false_type
        {
        };
        template<>
        struct is_allowed_type<std::string> : std::true_type
        {
        };
        template<>
        struct is_allowed_type<const char*> : std::true_type
        {
        };
        template<typename Return_type>
        Return_type return_value(const std::string& Key)
        {
            // This will be called.
            // Shouldn't matter if because get_value<ReturnType>() will throw an error.
            // Will not compile if Return_type has no default constructor.
            // Anyway, this should get the users attention, which is the primary goal.
            return Return_type();
        }
        template<>
        std::string return_value<std::string>(const std::string& Key)
        {
            return Key;
        }
        template<>
        const char* return_value<const char*>(const std::string& Key)
        {
            return Key.c_str();
        }
    }; // force_type
}; //ptree_type_safe

int main()
{
    using boost::property_tree::ptree;
    //ptree pt;
    ptree_type_safe pt; // use wrapper
    pt.put("key1", "1.2"); // insert a string in key1

    std::string val1 = pt.get<std::string>("key1"); // ok

    try
    {
        double val3 = pt.get<double>("key1"); // ideally would throw
    }
    catch (boost::property_tree::ptree_bad_data& Error)
    {
        std::cout << Error.what() << std::endl;
    }
    return 0;
}