Hi There, I am using the Boost.MultiIndex and I am facing a problem that I am try to resolving (debbuging) already about 20 hours... I think I get the problem isolated, but I don't know how to solve, and I don't know if this it is implemented. So I decided to make a example, it is a little big, but I put it as resumed as I could and post here in order to know if anyone could help me out. I will try to explain briefly here, I will copy the main() code right under the explanation, but the whole code of the example is in the end of the e-mail (with the classes and functions) If you want you could try to run too see what is the problem that I am talking about.) When I try to access an pair of iterators pair that I stored inside a class (propertystream_h), somehow is changing to where the iterator points, I think it could be because the object which has originate (Graph) the index is created, stored in in a static index (which I call _graphRep) from the DynamicGraphs, passed to a handler (Graph_h), and then after the Graph goes out of scope it is destroyed. When the Graph_h._localGraph (copy of the iterator->Graph returned by the insertion in the _graphRep) access its member _globalProperties (which is an index containing the fields: {string _key, string _value, propertystream_h _props} from the struct globalPropSchema) through a iterator (let's call it: gpit), then it is fine. But then when I try to access through the gpit->_props._propRangeIt.first, the iterator of the propertystream_h (_propRangeIt.first), then the iterators, some how are messed up. ( -> in this example it points to last element, and then when I get next, never finds the end(). (sometimes it return some trash, sometimes I get segmentation fault). So I would like to know why it is messing with the iterator? And how could I solve this problem? that's it, best regards, Rodrigo P.S.: I hope someone can help me... copy of the main(): int main(){ DynamicGraphs dg; Graph_h graph_h; propertystream_h propS; property_h prop_h; GlobalPropIterator gpit; GlobalProp_h gp_h; propertystream_h ps_h; property_h p_h; graph_h = dg.createGraph("COI:0351-123-4555"); if (!graph_h) cout << "Unsuccessful creation!"<lookupLocalProp("name"); while(!ps_h.end()){ cout << "LocalProperties: "; p_h=ps_h.next(); cout << "Key: " << p_h.key() << " Value: " << p_h.value() < after a lot of debugging (about 16h) OI found out that // it seems that during the creation of a graph, // when it passes the graph to graph_h, and goes out of scope, it keep the // iterator reference to the first element, but just that... the next // gives me segmentation fault. Anyone knows how to pass the graph and the its members // the indexes-repositories as value, so it would not depend on the pointing to // the graph that was freed from the memory? gpit = graph_h->properties("*"); if (!gpit) cout << "Not found any property in the globalProperties Repository."< #include #include #include #include #include #include #include #include <climits> #include <iomanip> #include <iostream> #include <ctime> #include <string> #if !defined(NDEBUG) #define BOOST_MULTI_INDEX_ENABLE_INVARIANT_CHECKING #define BOOST_MULTI_INDEX_ENABLE_SAFE_MODE #endif using std::string; using std::pair; using std::ostream; using std::cout; using std::endl; using boost::multi_index_container; using namespace boost::multi_index; struct property { string _key; string _value; /// Default Constructor property(){} /// Constructor with parameters: initialize the name and graph property(string key, string value) : _key(key), _value(value) {} /// Copy Contructor property(const property &pm) : _key(pm._key), _value(pm._value) {} //For debugging TODO: delete later friend ostream& operator<<(ostream& os, const property &p){ os << "Key: " << p._key << " value: " << p._value << endl; return os; } }; /// Indexing in the data structure PropMap typedef multi_index_container< property, indexed_by< hashed_non_unique< BOOST_MULTI_INDEX_MEMBER(property, string, _key) > >

propIndex;

typedef propIndex::iterator propIt; class property_h { private: /// Access to properties through the iterator propIt _pit; public: /// Default Constructor property_h(){} /// Constructor with Parameters: for lookup of Nodes property_h (const propIt &it) : _pit(it){} /// Constructor with Parameters: for lookup of Nodes property_h (const property_h &h) : _pit(h._pit){} /// Returns the key from the property being handled string key() const {return _pit->_key;} /// Returns the value from the property being handled string value() const {return _pit->_value;} }; class propertystream_h { /// _propRangeIt: for keeping a range in order to iterate over the graphs pair _propRangeIt; /// _noMatches: true if there are no matches during the lookup function bool _noMatches; public: /// Default Constructor propertystream_h() : _noMatches(true){} /// Constructor with parameters for local lookup propertystream_h(pair rangeIt, bool noMatches) : _propRangeIt(rangeIt), _noMatches(noMatches){ } /// Default Constructor propertystream_h(const propertystream_h &ps) : _propRangeIt(ps._propRangeIt), _noMatches(ps._noMatches){} // returns null_h on end of stream ... property_h next(){ return property_h(_propRangeIt.first++); } /// This function returns true whenever is the end of the stream bool end(){ return (_propRangeIt.first == _propRangeIt.second); } /// Overload operator!: shows if a creation was unsuccessful bool operator!(){ return _noMatches; } }; struct globalPropSchema{ string _key; string _value; propertystream_h _props; /// Default Constructor globalPropSchema() : _key(""), _value(""), _props(){} /// Parameter Constructor globalPropSchema(string k, string value, propertystream_h props) : _key(k), _value(value), _props(props){} /// Copy Constructor globalPropSchema(const globalPropSchema &gps) : _key(gps._key), _value(gps._value), _props(gps._props){} //TODO: Delete it: Debug friend ostream& operator<<(ostream &os, const globalPropSchema &gps){ os << "Key: " << gps._key << " Value: "<< gps._value << " PropertyStreamAdress: " << &gps._props <, composite_key_compare< std::greater<string>, std::less<string> > > >

grobalProperties;

/// Iterator for the data structure of the global properties index typedef grobalProperties::iterator globalPropIt; class GlobalProp_h{ private: /// Access to globalPropertiest items through the iterator globalPropIt _gpit; public: /// Default Constructor GlobalProp_h(){} /// Constructor with Parameters: for lookup of Nodes GlobalProp_h (const globalPropIt &it) : _gpit(it){} /// Copy Constructor GlobalProp_h (const GlobalProp_h &gph) : _gpit(gph._gpit){} /// Access to key of globalPropeties items string key(){ return _gpit->_key;} /// Access to value of globalPropeties items string value(){return _gpit->_value;} propertystream_h propertyStreamHandler(){ return _gpit->_props; } }; /// Iterator for the data structure of the global properties index typedef grobalProperties::iterator globalPropIt; class GlobalPropIterator{ private: /// _propRangeIt: for keeping a range in order to iterate over the graphs pair _globalPropRangeIt; /// _noMatches: true if there are no matches during the lookup function bool _noMatches; public: /// Default Constructor GlobalPropIterator(){} /// Constructor with parameters for local lookup GlobalPropIterator(pair rangeIt, bool noMatches) : _globalPropRangeIt(rangeIt), _noMatches(noMatches){} /// Default Constructor GlobalPropIterator(const GlobalPropIterator &gpi) : _globalPropRangeIt(gpi._globalPropRangeIt), _noMatches(gpi._noMatches){} // returns null_h on end of stream ... GlobalProp_h next(){ return GlobalProp_h(_globalPropRangeIt.first++); } /// This function returns true whenever is the end of the stream bool end(){ return (_globalPropRangeIt.first == _globalPropRangeIt.second); } /// Overload operator!: shows if a creation was unsuccessful bool operator!(){ return _noMatches; } }; class Graph { private: propIndex _localPropRep; /// Repository for the properties of the global properties related to the graph; grobalProperties _globalPropRep; public: // TODO: Really constructors /// Default Constructor Graph() {} /// Copy constructors Graph(const Graph &g) : _localPropRep(g._localPropRep), _globalPropRep(g._globalPropRep){} bool addProperty(string key, string value); GlobalPropIterator properties(string pattern) const; /// Function to lookup Local Properties propertystream_h lookupLocalProp(string pattern); friend class Graph_h; }; /// GraphMap: Data Structure for setting an index in the uniqueGraphName and retrieving handler Graph_h struct graphMap { string _name; Graph _graph; /// Default Constructor graphMap(){} /// Constructor with parameters: initialize the name and graph graphMap(string uniqueGraphName, Graph graph) : _name(uniqueGraphName), _graph (graph) {} /// Constructor with parameters: initialize the name and graph graphMap(const graphMap &gm) : _name(gm._name), _graph (gm._graph) {} }; ///ordered_unique Index in the data structure graph_hm typedef multi_index_container< graphMap, indexed_by< ordered_unique< BOOST_MULTI_INDEX_MEMBER(graphMap,string,_name) > >

graphIndex;

/// Defing an iterator for the graphMapIndex typedef graphIndex::iterator graphIt; class Graph_h { private: /// \brief GraphIterator: Iterator pointing to the Graph graphIt _git; Graph _localGraph; bool _createSuccess; public: /// Default Constructor Graph_h() : _createSuccess(false) {} /// Constructor with Parameters: for creation of Graphs Graph_h ( pair creation) : _git(creation.first), _createSuccess(creation.second){ _localGraph = creation.first->_graph; } /// Constructor with Parameters: for lookup of Graphs Graph_h (const graphIt &it) : _git(it), _createSuccess(false){ _localGraph = it->_graph; } /// Constructor with Parameters: for lookup of Graphs Graph_h (const Graph_h &h) : _git(h._git), _localGraph(h._localGraph), _createSuccess(h._createSuccess){} bool operator!(){ return !_createSuccess; } /// Operator-> overloading: allows access to graph members Graph* operator->() {return &_localGraph;} }; propertystream_h Graph::lookupLocalProp(string pattern){ pair rangeIt; propIt rangeItfirst = _localPropRep.find(pattern); rangeIt.first = rangeItfirst; rangeIt.second = _localPropRep.end(); if (rangeIt.first != _localPropRep.end()) // second parameter means that the variable noMatches, so false in case that found the key return propertystream_h(rangeIt, false); else //No matches return propertystream_h(rangeIt, true); } GlobalPropIterator Graph::properties(string pattern) const{ pair globalRangePropIt; bool noMatchesTmp=false; //Whole range if (!pattern.compare("*")){ globalRangePropIt.first = _globalPropRep.begin(); globalRangePropIt.second = _globalPropRep.end(); } if (globalRangePropIt.first == globalRangePropIt.second) noMatchesTmp = true; return GlobalPropIterator(globalRangePropIt, noMatchesTmp); } bool Graph::addProperty(string key, string value){ bool boolLocal, boolGlobal; pair rangePropIt; string globalKey = "graph:"; globalKey.append(key); // "graph:namePorperty" boolLocal = _localPropRep.insert(property(key,value)).second; //Defining the whole range for iterate over the local properties rangePropIt.first = _localPropRep.begin(); rangePropIt.second = _localPropRep.end(); //Debug propIt it = rangePropIt.first; cout << "How it should be showed when accessing the iterator..."<lookupLocalProp("name"); while(!ps_h.end()){ cout << "LocalProperties: "; p_h=ps_h.next(); cout << "Key: " << p_h.key() << " Value: " << p_h.value() < after a lot of debugging (about 16h) OI found out that // it seems that during the creation of a graph, // when it passes the graph to graph_h, and goes out of scope, it keep the // iterator reference to the first element, but just that... the next // gives me segmentation fault. Anyone knows how to pass the graph and the its members // the indexes-repositories as value, so it would not depend on the pointing to // the graph that was freed from the memory? gpit = graph_h->properties("*"); if (!gpit) cout << "Not found any property in the globalProperties Repository."<http://dsl.gmx.de/?ac=OM.AD.PD003K11308T4569a