| Home | Libraries | People | FAQ | More

## Reference

### Header <boost/property_tree/exceptions.hpp>

    namespace boost {
      namespace property_tree {
        class ptree_bad_data;
        class ptree_bad_path;
        class ptree_error;
      }
    }

### Header <boost/property_tree/id_translator.hpp>

    namespace boost {
      namespace property_tree {
        template<typename Ch, typename Traits, typename Alloc>
          struct translator_between<std::basic_string< Ch, Traits, Alloc >, std::basic_string< Ch, Traits, Alloc >>;
        template<typename T> struct translator_between<T, T>;
      }
    }

### Header <boost/property_tree/info_parser.hpp>

    namespace boost {
      namespace property_tree {
        namespace info_parser {
          template<typename Ptree, typename Ch>
            void read_info(std::basic_istream< Ch > &, Ptree &);
          template<typename Ptree, typename Ch>
            void read_info(std::basic_istream< Ch > &, Ptree &, const Ptree &);
          template<typename Ptree>
            void read_info(const std::string &, Ptree &,
                           const std::locale & = std::locale());
          template<typename Ptree>
            void read_info(const std::string &, Ptree &, const Ptree &,
                           const std::locale & = std::locale());
          template<typename Ptree, typename Ch>
            void write_info(std::basic_ostream< Ch > &, const Ptree &,
                            const info_writer_settings< Ch > & = info_writer_settings< Ch >());
          template<typename Ptree>
            void write_info(const std::string &, const Ptree &,
                            const std::locale & = std::locale(),
                            const info_writer_settings< typename Ptree::key_type::value_type > & = info_writer_make_settings< typename Ptree::key_type::value_type >());
        }
      }
    }

### Header <boost/property_tree/ini_parser.hpp>

    namespace boost {
      namespace property_tree {
        namespace ini_parser {
          class ini_parser_error;
          bool validate_flags(int);
          template<typename Ptree>
            void read_ini(std::basic_istream< typename Ptree::key_type::value_type > &,
                          Ptree &);
          template<typename Ptree>
            void read_ini(const std::string &, Ptree &,
                          const std::locale & = std::locale());
          template<typename Ptree>
            void write_ini(std::basic_ostream< typename Ptree::key_type::value_type > &,
                           const Ptree &, int = 0);
          template<typename Ptree>
            void write_ini(const std::string &, const Ptree &, int = 0,
                           const std::locale & = std::locale());
        }
      }
    }

### Header <boost/property_tree/json_parser.hpp>

    namespace boost {
      namespace property_tree {
        namespace json_parser {
          template<typename Ptree>
            void read_json(std::basic_istream< typename Ptree::key_type::value_type > &,
                           Ptree &);
          template<typename Ptree>
            void read_json(const std::string &, Ptree &,
                           const std::locale & = std::locale());
          template<typename Ptree>
            void write_json(std::basic_ostream< typename Ptree::key_type::value_type > &,
                            const Ptree &, bool = true);
          template<typename Ptree>
            void write_json(const std::string &, const Ptree &,
                            const std::locale & = std::locale(), bool = true);
        }
      }
    }

### Header <boost/property_tree/ptree.hpp>

### Header <boost/property_tree/ptree_fwd.hpp>

    namespace boost {
      namespace property_tree {
        template<typename Key, typename Data, typename KeyCompare>
          class basic_ptree;

        template<typename T> struct id_translator;
        template<typename Key> struct path_of;
        template<typename Internal, typename External> struct translator_between;
        typedef string_path< std::string, id_translator< std::string > > path;
        typedef basic_ptree< std::string, std::string > ptree;
        typedef unspecified iptree;
        typedef string_path< std::wstring, id_translator< std::wstring > > wpath;
        typedef basic_ptree< std::wstring, std::wstring > wptree;
        typedef unspecified wiptree;
        template<typename K, typename D, typename C>
          void swap(basic_ptree< K, D, C > &, basic_ptree< K, D, C > &);
      }
    }

### Header <boost/property_tree/ptree_serialization.hpp>

    namespace boost {
      namespace property_tree {
        template<typename Archive, typename K, typename D, typename C>
          void save(Archive &, const basic_ptree< K, D, C > &, const unsigned int);
        template<typename Archive, typename K, typename D, typename C>
          void load(Archive &, basic_ptree< K, D, C > &, const unsigned int);
        template<typename Archive, typename K, typename D, typename C>
          void serialize(Archive &, basic_ptree< K, D, C > &, const unsigned int);
      }
    }

### Header <boost/property_tree/stream_translator.hpp>

    namespace boost {
      namespace property_tree {
        template<typename Ch, typename Traits, typename E,
                 typename Enabler = void>
          struct customize_stream;

        template<typename Ch, typename Traits>
          struct customize_stream<Ch, Traits, bool, void>;
        template<typename Ch, typename Traits>
          struct customize_stream<Ch, Traits, Ch, void>;
        template<typename Ch, typename Traits, typename F>
          struct customize_stream<Ch, Traits, F, typename boost::enable_if< detail::is_inexact< F > >::type>;
        template<typename Ch, typename Traits>
          struct customize_stream<Ch, Traits, signed char, void>;
        template<typename Ch, typename Traits>
          struct customize_stream<Ch, Traits, unsigned char, void>;

        template<typename Ch, typename Traits, typename Alloc, typename E>
          class stream_translator;

        template<typename Ch, typename Traits, typename Alloc, typename E>
          struct translator_between<std::basic_string< Ch, Traits, Alloc >, E>;
      }
    }

### Header <boost/property_tree/string_path.hpp>

    namespace boost {
      namespace property_tree {
        template<typename Ch, typename Traits, typename Alloc>
          struct path_of<std::basic_string< Ch, Traits, Alloc >>;

        template<typename String, typename Translator> class string_path;
        template<typename String, typename Translator>
          string_path< String, Translator >
          operator/(string_path< String, Translator > p1,
                    const string_path< String, Translator > & p2);
        template<typename String, typename Translator>
          string_path< String, Translator >
          operator/(string_path< String, Translator > p1,
                    const typename String::value_type * p2);
        template<typename String, typename Translator>
          string_path< String, Translator >
          operator/(const typename String::value_type * p1,
                    const string_path< String, Translator > & p2);
      }
    }

### Header <boost/property_tree/xml_parser.hpp>

    namespace boost {
      namespace property_tree {
        namespace xml_parser {
          template<typename Ptree>
            void read_xml(std::basic_istream< typename Ptree::key_type::value_type > &,
                          Ptree &, int = 0);
          template<typename Ptree>
            void read_xml(const std::string &, Ptree &, int = 0,
                          const std::locale & = std::locale());
          template<typename Ptree>
            void write_xml(std::basic_ostream< typename Ptree::key_type::value_type > &,
                           const Ptree &,
                           const xml_writer_settings< typename Ptree::key_type > & = xml_writer_settings< typename Ptree::key_type >());
          template<typename Ptree>
            void write_xml(const std::string &, const Ptree &,
                           const std::locale & = std::locale(),
                           const xml_writer_settings< typename Ptree::key_type > & = xml_writer_settings< typename Ptree::key_type >());
        }
      }
    }