September 2007 - Boost-users - lists.preview.boost.org

Deciding parameter for adjancency list at runtime.
by abhishek.v＠tcs.com 11 Sep '07

11 Sep '07

Hi I have a function which take an input from the user whether the graph is directed or undirected. I'm declaring graph as follows :- typedef adjacency_list < vecS, vecS, undirectedS, property < vertex_name_t,std::string >, property < edge_name_t, std::string > > Graph; Graph g; Now here the parameter in Bold need to be varied as the user input changes. One method could be i could have two different function say,CreateDirected() and CreateUndirected(). But this is not working in my case as i want the declaration should be global so that i can use it throughout my application. Please help. Abhishek Vyas Tata Consultancy Services Mailto: abhishek.v(a)tcs.com Website: http://www.tcs.com ____________________________________________ Experience certainty. IT Services Business Solutions Outsourcing ____________________________________________ =====-----=====-----===== Notice: The information contained in this e-mail message and/or attachments to it may contain confidential or privileged information. If you are not the intended recipient, any dissemination, use, review, distribution, printing or copying of the information contained in this e-mail message and/or attachments to it are strictly prohibited. If you have received this communication in error, please notify us by reply e-mail or telephone and immediately and permanently delete the message and any attachments. Thank you

3 2

Kamada kawai spring layout algorithm
by Meththa 11 Sep '07

11 Sep '07

Hi, I am a newbie to Boost and would like some help with implementing a program. I want to use the Kamada Kawai spring layout algorithm and I do not know what to pass for the final parameter when calling the function. the template of the function is given below. template<typename Graph, typename PositionMap, typename WeightMap, typename T, bool EdgeOrSideLength> bool kamada_kawai_spring_layout(const Graph & g, PositionMap position, WeightMap weight, unspecified edge_or_side_length); I do not understand what value needs to be given and what type for unspecified edge_or_side_length. Can someone please point me in the right direction with regards to this. Thanks ____________________________________________________________________________________Ready for the edge of your seat? Check out tonight's top picks on Yahoo! TV. http://tv.yahoo.com/

2 1

BGL adaption question
by Andreas Fabri 11 Sep '07

11 Sep '07

Hello, I adapt my own graph like data structures. They form a derivation hierarchy, and they are all in the same graph category. In order to avoid that I have to repeat the specializations of the graph traits, I put all the types needed in the base class, so the default graph traits, which just takes the types out of the class it is applied to, will get them from the base class or via inherited types from the base class. What can I do in order to repeat the definition of the functions source(..), target(..) etc. I could tell my users to downcast but that's not nice. I also could have #defines for all my classes so that I write the code only once, but all these solutions are not appealing. any suggestion? andreas

2 1

a question about message_queue
by nuaafantasy nuaafantasy 11 Sep '07

11 Sep '07

Dear All: My project use messge_queue to communicate between two processes. When I used the processes as normal process,it runs well. but It seems that the client process can't access the message queue if I set the server process as a windows services. can you help me about this? is this a problem about privilege? but message_queue do not have a option to set privileges. looking forward to your help!

2 2

Smart pointers operator=
by Alessandro Re 11 Sep '07

11 Sep '07

Hi, can please someone explain me why in boost's smart pointers (and also in auto_ptr, if there is a reason), there is no operator=(T *)? Shouldn't it work like reset()? Thanks -- ~Ale

3 5

If you are using the BGL and want to be listed here
by Andreas Fabri 11 Sep '07

11 Sep '07

Hello, On the page http://www.boost.org/libs/graph/doc/users.html it says: "If you are using the BGL and want to be listed here, please send mail to the Boost Users mailing list!" We would be glad if you added something like CGAL, the Computational Algorithms Library, offers external adaption for triangulations, polyhedral surfaces, and arrangements. These data structures become hence models of the BGL graph concept and allow to run BGL algorithms on them. http://www.cgal.org/Pkg/BGL Best regards, Andreas Fabri

1 0

[multi_index] erasing elements
by Jeff Holle 11 Sep '07

11 Sep '07

I'm using boost::multi_index obtained via CVS on Fri Jun 29 12:30:03 EDT 2007. In my application, I'm using a multi_index container that has one ordered index. Call the container Present and the index YIndex. I'm at the point in which I need to erase an element which returns a YIndex::iterator. Its important that I know the neighbors of the element erased with respect to the YIndex. I know that the element which I look for in the container must exist, so I have an assert that will fail if the searched for element isn't found. If I code it like this: YIndex& index=m_present.get<0>(); YIndex::iterator iter = index.begin(); for (;iter!=index.end();++iter) if (m_future.top().getEdges().first == iter->getEdge()) break; assert(iter!=index.end()); iter = index.erase(iter); The assert goes off the 4th time this code runs. If I change the code to this: Present::iterator iter = m_present.begin(); for (;iter!=m_present.end();++iter) if (m_future.top().getEdges().first == iter->getEdge()) break; assert(iter!=m_present.end()); iter = m_present.erase(iter); The application runs to completion, but since I need YIndex::iterators I can't code what is needed by my application. I'm assuming that calling erase corrupts the ordered index. What do I have to do to correct this?

2 1

[spirit]how to ignore the sequence of the rules?
by moosefly 11 Sep '07

11 Sep '07

For example, I want to parse the following text: <input type=hidden value=1> I have defined 2 rules match the "type" field and the "value" field, but the sequence of 2 rules is uncertain, that means "<input value=1 type=hidden>" is also legal,so I can't define the rules just like: rule_type >> !space_p >> rule_value The following works at this simple condition: ( (rule_type >> !space_p >> rule_value) | (rule_value >> !space_p >>rule_type ) ) But if there are many out-of-order fields need to parser, how can I ignore the sequence of the rules? Thanks, moosefly

1 0

Creating directory structure recursively using create_directories()
by Rajesh Jadhav 10 Sep '07

10 Sep '07

Hello All, I am trying to create a directory structure having 4 to 5 levels. When I try to call the boost::filesystem::create_directories(src); It throws an exception saying that path does not exist .So isn't create_directories() mean't for creating directory structure recursively or is there a other api which does it. I could not find Api's which can split the path ,and give the directory names in the path starting after the root directory up to leaf directory . I am attaching the sample code . #include <iostream> #include "boost/filesystem/operations.hpp" #include "boost/filesystem/path.hpp" #include "boost/filesystem/convenience.hpp" int main() { const char* srcPath = "C:\\tmp\\dir1\\dir2\\dir3\\"; (this structure does not exist) boost::filesystem::path src = boost::filesystem::path(srcPath, boost::filesystem::no_check); try { boost::filesystem::create_directories(relativepath); // throws exception if(src.has_branch_path()) { boost::filesystem::path branchpath = src.branch_path(); std::cout << branchpath.string(); // prints C: boost::filesystem::path rootpath = src.root_path(); std::cout << rootpath.string(); //prints C: boost::filesystem::path relativepath = src.relative_path(); std::cout << relativepath.string(); //prints tmp\\dir1\\dir2\\dir3\\ } } catch(std::exception& ex) { std::cout << ex.what() << std::endl; } return 0; } Thanks in advance for the replies. Rajesh

1 0

[serialization] improved demo_shared_ptr.cpp using XML archive
by Robbie Morrison 10 Sep '07

10 Sep '07

Hello all The 'demo_shared_ptr.cpp' example currently bundled with the Boost documentation has some problems. It would not compile without modification on my system (g++ 4.1/Ubuntu 6.10). And it took quite some work to make XML the archive format if one is not familiar with the Boost.Serialization library. The code below, I hope, represents an improvement. I will happily take on-board any suggestions and fixes (descriptive or diffs as suits) and will resubmit a modified example back to this list in due course. Furthermore, it may be appropriate to add the final version of this file to the official Boost documentation. Alternatively, I can put it on the Boost Wiki as an unofficial contribution. (Perhaps Robert can advise on which approach would be better?) Finally, some search terms which might help locate this posting: unregistered void cast sp_counted_base_impl oa.register_type with best wishes Robbie --- Robbie Morrison PhD student -- policy-oriented energy system simulation Institute for Energy Engineering (IET) Technical University of Berlin (TU-Berlin), Germany 8<--------------------------------------------------------------- // demo_shared_ptr_xml.cpp : demos polymorphic pointer XML serialization // ******************************************************************* // MODIFICATION WARNING: this file has been modified by a Boost user // and is not part of the official Boost distribution. // ******************************************************************* // (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . Polymorphic // derived pointer example by David Tonge. XML archive format and bug // fixes added by Robbie Morrison <robbie(a)actrix.co.nz> on 10-Sep-2007. // Use, modification and distribution is subject to the Boost Software // License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org for updates, documentation, and revision history. // // Purpose // // This file demonstrates how base class pointers holding derived // class objects can be serialized and deserialized in one of // three archive formats: text, XML, and platform-specific binary. // // Important // // Note carefully that, in this example, the class hierarchy is // "polymorphic", which means that each parent class definition // contains at least one virtual function -- in this case, its // destructor. // // Base classes can also be abstract. Users may wish to // experiment by making class A abstract, in which case, the // following macro should be placed after the duly revised class // definition: BOOST_IS_ABSTRACT(A) // // Note also that a non-polymorphic class hierarchy will not // serialize derived instances without extra effort. In most // cases, it is simpler and less error-prone to declare all // relevant destructors as virtual. // // Text and binary archive formats can be selected by // redefining the ARCHIVE_FORMAT preprocessor macro in the // code below. The default format is XML. // // XML is a little more demanding code-wise because both the // object itself and a legal XML tag name need to be // specified. Often the simplest way to do this is to use a // Boost macro which automatically generates the tag name // from the C++ identifier, such as BOOST_SERIALIZATION_NVP(x) // and BOOST_SERIALIZATION_BASE_OBJECT_NVP(A). // // Testing // // This file has been tested with Boost release 1.34.1 dated // 24-Jul-2007 (source build) and also release 1.33.1 (Ubuntu // package) using the GNU GCC 4.1.2 compiler (with -Wall and // -pedantic), valgrind version "valgrind-3.2.0-Debian" memory // checker, and Linux Ubuntu 6.10 operating system (now superseded // by 7.04). The file builds and runs cleanly under the // conditions just listed. #include <iostream> // standard io #include <fstream> // file-based io #include <string> // C++ strings #include <boost/archive/tmpdir.hpp> // locate a temporary directory #include <boost/archive/text_oarchive.hpp> // save text archive #include <boost/archive/text_iarchive.hpp> // load text archive #include <boost/archive/xml_oarchive.hpp> // save XML archive #include <boost/archive/xml_iarchive.hpp> // load XML archive #include <boost/archive/binary_oarchive.hpp> // save non-portable binary archive #include <boost/archive/binary_iarchive.hpp> // load non-portable binary archive #include <boost/serialization/serialization.hpp> // friendship #include <boost/serialization/shared_ptr.hpp> // shared_ptr serialization #include <boost/serialization/base_object.hpp> // base class serialization #include <boost/serialization/is_abstract.hpp> // BOOST_IS_ABSTRACT macro #include <boost/serialization/export.hpp> // BOOST_CLASS_EXPORT macro (place last) // set some typedefs to enable the client code to shift between // archive formats without further effort (if you don't need this // flexibility, omit these typedefs and just use the original // type names, also remove any library headers that are now // surplus to requirements) // // 1 = text format, 2 = XML format, 3 = binary format #define ARCHIVE_FORMAT 2 #if (ARCHIVE_FORMAT == 1) typedef boost::archive::text_oarchive output_archive_type; typedef boost::archive::text_iarchive input_archive_type; const std::string archive_ext = "txt"; #elif (ARCHIVE_FORMAT == 2) typedef boost::archive::xml_oarchive output_archive_type; typedef boost::archive::xml_iarchive input_archive_type; const std::string archive_ext = "xml"; #elif (ARCHIVE_FORMAT == 3) typedef boost::archive::binary_oarchive output_archive_type; typedef boost::archive::binary_iarchive input_archive_type; const std::string archive_ext = "dat"; #endif // class A is a polymorphic base class, due to its virtual destructor class A { friend class boost::serialization::access; // intrusive serialization private: template <class Archive> void serialize (Archive& ar, const unsigned int class_version) { ar & BOOST_SERIALIZATION_NVP(x); // macro form //ar & boost::serialization::make_nvp("x", x); // statement form } int x; public: A(): x(42) { ++count; } // default constructor, the 42 is arbitrary virtual ~A() { --count; } static int count; // public to simplify test code (although not used) }; // the following macro is needed for derived classes, but does no harm for base classes // BOOST_CLASS_EXPORT(A) // requires <boost/serialization/export.hpp> // uncomment if making class A abstract (left as an exercise for users) // BOOST_IS_ABSTRACT(A) // requires <boost/serialization/is_abstract.hpp> // uncomment if using particular Metrowerks or Borland compilers // BOOST_SERIALIZATION_SHARED_PTR(A) int A::count = 0; // derived class B was originally added by David Tonge class B : public A { friend class boost::serialization::access; private: template<class Archive> void serialize(Archive& ar, const unsigned int class_version) { ar & BOOST_SERIALIZATION_BASE_OBJECT_NVP(A); // this works fine in all cases //ar & boost::serialization::base_object<A>(*this); // CAUTION: problematic for XML ar & BOOST_SERIALIZATION_NVP(x); } int x; public: B() : x(84) { ++count; } // default constructor, the 84 is arbitrary virtual ~B() { --count; } static int count; }; // uncomment if using particular Metrowerks or Borland compilers // BOOST_SERIALIZATION_SHARED_PTR(B) // if omitted, an "unregistered class" boost::archive::archive_exception is thrown BOOST_CLASS_EXPORT(B) // strictly necessary as B is derived int B::count = 0; // display details for two supposedly common shared pointers void display(std::string tag, boost::shared_ptr<A>& a0, boost::shared_ptr<A>& a1) { std::cout << tag << "0: address = 0x" << std::hex << a0.get() << std::dec; if (a0.get()) std::cout << ", underlying typeid = " << typeid(*(a0.get())).name(); std::cout << ", use_count = " << a0.use_count() << std::endl; std::cout << tag << "1: address = 0x" << std::hex << a1.get() << std::dec; if (a1.get()) std::cout << ", underlying typeid = " << typeid(*(a1.get())).name(); std::cout << ", use_count = " << a1.use_count() << std::endl; std::cout << std::endl; } // main code int main(int argc, char* argv[]) { // name the archive file std::string filename(boost::archive::tmpdir()); //locate a temporary directory filename += "/demo_shared_ptr_xml."; // filename stub filename += archive_ext; // "txt", "xml", "dat" const char* cfilename = filename.c_str(); // convert to C-stye string // part one std::cout << std::endl; std::cout << "original pointers" << "\n" << std::endl; // create two new type A shared pointers to hold a single type A object boost::shared_ptr<A> spa0(new A()); // spa0(new A) would also be acceptable boost::shared_ptr<A> spa1; spa1 = spa0; // both now own the same type A object display("spa", spa0, spa1); // new code by David Tonge starts here // create two new type A shared pointers to hold a single type B object boost::shared_ptr<A> spb0(new B()); // a derived and also polymorphic pointer boost::shared_ptr<A> spb1; spb1 = spb0; display("spb", spb0, spb1); // serialize the four pointers // // it would be better practice to make the following block a // try block and then catch exceptions (but this code has // been omitted for reasons of simplicity) { std::ofstream ofs(cfilename, std::ios::binary); output_archive_type oa(ofs); // see earlier typedefs oa << BOOST_SERIALIZATION_NVP(spa0); oa << BOOST_SERIALIZATION_NVP(spa1); oa << BOOST_SERIALIZATION_NVP(spb0); oa << BOOST_SERIALIZATION_NVP(spb1); // 'ofs' and 'oa' are automatically destructed on exiting this block } // part two std::cout << "reset pointers" << "\n" << std::endl; // reset each shared pointer to hold a type A* null pointer spa0.reset(); spa1.reset(); // last shared pointer, held object duly deallocated spb0.reset(); spb1.reset(); // last shared pointer, held object duly deallocated display("spa", spa0, spa1); display("spb", spb0, spb1); // part three std::cout << "reinstated pointers" << "\n" << std::endl; // restore program state to one equivalent to the original { std::ifstream ifs(cfilename, std::ios::binary); input_archive_type ia(ifs); ia >> BOOST_SERIALIZATION_NVP(spa0); ia >> BOOST_SERIALIZATION_NVP(spa1); ia >> BOOST_SERIALIZATION_NVP(spb0); ia >> BOOST_SERIALIZATION_NVP(spb1); } display("spa", spa0, spa1); display("spb", spb0, spb1); // report archive name std::cout << "archive name: " << filename << "\n" << std::endl; return 0; } // main() // --------------------------------- // Output (typeid is compiler-dependent) // --------------------------------- // // original pointers // // spa0: address = 0x0x4e719e0, underlying typeid = 1A, use_count = 2 // spa1: address = 0x0x4e719e0, underlying typeid = 1A, use_count = 2 // // spb0: address = 0x0x4e71a98, underlying typeid = 1B, use_count = 2 // spb1: address = 0x0x4e71a98, underlying typeid = 1B, use_count = 2 // // reset pointers // // spa0: address = 0x0, use_count = 0 // spa1: address = 0x0, use_count = 0 // // spb0: address = 0x0, use_count = 0 // spb1: address = 0x0, use_count = 0 // // reinstated pointers // // spa0: address = 0x0x4e7b308, underlying typeid = 1A, use_count = 2 // spa1: address = 0x0x4e7b308, underlying typeid = 1A, use_count = 2 // // spb0: address = 0x0x4e7c600, underlying typeid = 1B, use_count = 2 // spb1: address = 0x0x4e7c600, underlying typeid = 1B, use_count = 2 // // archive name: ./demo_shared_ptr_xml.xml // end-of-file demo_shared_ptr_xml.cpp --------------------------------------------------------------->8 [from IMAP client]

1 0