2

我正在寻找一种与boost::property_tree非常相似的结构。但是它应该更安全一点，例如我想在我这样做时得到一个异常：

#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;
}

基本上我正在寻找案例 #2 的实现，如[34.4] 如何构建不同类型的对象？. 我的容器应该允许嵌套案例（容器的容器）。

4

1 回答 1

1

您可以尝试通过强制通过 Translator 访问数据来强制使用类型。

这意味着，您可以创建一个环绕/模仿 property_tree 接口的类，但添加一些额外的实现特性来尝试控制类型。

我提供了一个简单的类 ptree_type_safe，它模仿了 property_tree 的一些数据访问接口（put() 和 get()），但只允许检索某些类型。如果您运行代码，它应该在调用时打印 ptree_bad_data 错误消息double val3 pt.get<double>("key1")。

#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;
}
于 2017-10-03T08:26:24.323 回答