"Marcin Kalicinski" <kalita@poczta.onet.pl> wrote in message news:e327rh$9tu$1@sea.gmane.org...
There are more operations one can perform on a node than just getting. So I would rather replace operator () overload with explicitly named functions: get, put, set, del.
The use will look like that:
int n = pt["a.very"]["long"]["path"].get<int>(); pt["a.very"]["long"]["path"].del(); pt["a.very"]["long"]["path"].put(17);
I would rather expect something like the following. This makes a path a simple object. Other required path functionality might be serialising to/from a file as has been wished for, but that is trivial and output specific IMO using namespace boost::assign; typedef std::string path_element1; std::vector<path_element1> path1; path1 += "a","very","long","path"; boost::property_tree<path_element1> pt1; int n1 =pt1.get(path1,n1); pt1[path1].del(); pt1[path1].put(17); typedef int path_element2; std::vector<path_element2> path2; path2 += 1,2,3,4; boost::property_tree<path_element2> pt2; int n2 = pt2.get(pt2,n2); pt2[path2].del(); pt2[path2].put(17); } regards Andy Little (FWIW a 5 minute impl of such tree with root and branch functionality follows ---> ----------------------------------- #include <cassert> namespace boost{ template <typename Key> struct node; /* ABC class for elements of member nodes of a property_tree */ template <typename Key> struct abc_node_element{ private: friend struct node<Key>; protected: const Key m_key; abc_node_element(Key const & key) : m_key(key){} virtual ~abc_node_element(){}; virtual abc_node_element* clone() const =0; abc_node_element():m_key(Key()){}; }; /* node_element implementation for member nodes of property_tree root or branch depends on Data parameter Data is a container (list/vector/property_tree etc) for branch or just data for data */ template <typename Key, typename Data> struct node_element : abc_node_element <Key>{ node_element(Key const & k, Data const & d) : abc_node_element<Key>(k), m_data (d){} Data m_data; void put(Data const & d){m_data = d;} abc_node_element<Key>* clone() const { return new node_element(this->m_key,this->m_data); } }; /* a member property_tree node holds a private polymorphic node_element */ template <typename Key> struct node{ node():m_element(0){} node& operator = (node const & in); node(node const &); template <typename Data> node( Key const & k, Data const & d) { m_element = new node_element<Key,Data>(k,d); } ~node(){ delete m_element;} template <typename AltData> void put(AltData const & d) { assert(this->m_element); Key k = this->m_element->m_key; delete m_element ; m_element = 0; m_element = new node_element<Key,AltData>(k,d); } void del(){delete m_element; m_element = 0;} template <typename T> T & get() { node_element<T>* pe = dynamic_cast<node_element<T>*> m_element; assert (pe); return pe->get(); } template <typename T> T const & get() const { const node_element<T>* pe = dynamic_cast<const node_element<T>*> m_element; assert (pe); return pe->get(); } private: abc_node_element<Key>* m_element; }; template <typename KeyType> struct property_tree{ node<KeyType> m_node; template <typename Path> node<KeyType> & operator[]( Path const & p); template <typename Path> node<KeyType> const & operator[]( Path const & p)const; template <typename Path, typename Data> Data& get(Path const & p, Data & d); }; }//boost //---------------------------- #include <boost/assign.hpp> #include <vector> #include <string> int main() { using namespace boost::assign; typedef std::string path_element1; std::vector<path_element1> path1; path1 += "a","very","long","path"; boost::property_tree<path_element1> pt1; int n1 =pt1.get(path1,n1); pt1[path1].del(); pt1[path1].put(17); typedef int path_element2; std::vector<path_element2> path2; path2 += 1,2,3,4; boost::property_tree<path_element2> pt2; int n2 = pt2.get(pt2,n2); pt2[path2].del(); pt2[path2].put(17); }