- Boost - lists.boost.org

Re: [boost] [graph] dfs depending on VertexList container
by fabien.castan＠free.fr 09 Sep '10

09 Sep '10

> It also appears that you are not passing in your color map in main.cpp yes and in this case it should be created internally by the dfs function. > If your graph has a vertex_index_map property map (filled in appropriately) If I use bundle properties is there an automatic vertex_index_map ? > It's not just to initialize the color map, but to use it during the > algorithm as well. ok > Could you please send your full error trace? Exactly the same code works with vecS. In file included from /usr/include/c++/4.4/backward/hash_set:59, from .../extern/boost/boost/pending/container_traits.hpp:23, from .../extern/boost/boost/graph/detail/adjacency_list.hpp:31, from .../extern/boost/boost/graph/adjacency_list.hpp:324, from applications/testGraph/src/main.cpp:3: /usr/include/c++/4.4/backward/backward_warning.h:28:2: warning: #warning This file includes at least one deprecated or antiquated header which may be removed without further notice at a future date. Please use a non-deprecated interface with equivalent functionality instead. For a listing of replacement headers and interfaces, consult the file backward_warning.h. To disable this warning use -Wno-deprecated. In file included from .../extern/boost/boost/graph/named_function_params.hpp:23, from .../extern/boost/boost/graph/depth_first_search.hpp:22, from applications/testGraph/src/main.cpp:5: .../extern/boost/boost/property_map/shared_array_property_map.hpp: In member function 'T& boost::shared_array_property_map<T, IndexMap>::operator[](typename boost::property_traits<IndexMap>::key_type) const [with T = boost::default_color_type, IndexMap = boost::adj_list_vertex_property_map<boost::adjacency_list<boost::vecS, boost::listS, boost::bidirectionalS, Vertex, Edge, boost::no_property, boost::listS>, boost::detail::error_property_not_found, const boost::detail::error_property_not_found&, boost::vertex_index_t>]': .../extern/boost/boost/property_map/property_map.hpp:325: instantiated from 'void boost::put(const boost::put_get_helper<Reference, PropertyMap>&, K, const V&) [with PropertyMap = boost::shared_array_property_map<boost::default_color_type, boost::adj_list_vertex_property_map<boost::adjacency_list<boost::vecS, boost::listS, boost::bidirectionalS, Vertex, Edge, boost::no_property, boost::listS>, boost::detail::error_property_not_found, const boost::detail::error_property_not_found&, boost::vertex_index_t> >, Reference = boost::default_color_type&, K = void*, V = boost::default_color_type]' .../extern/boost/boost/graph/depth_first_search.hpp:197: instantiated from 'void boost::depth_first_search(const VertexListGraph&, DFSVisitor, ColorMap, typename boost::graph_traits<Graph>::vertex_descriptor) [with VertexListGraph = boost::adjacency_list<boost::vecS, boost::listS, boost::bidirectionalS, Vertex, Edge, boost::no_property, boost::listS>, DFSVisitor = CycleDetector, ColorMap = boost::shared_array_property_map<boost::default_color_type, boost::adj_list_vertex_property_map<boost::adjacency_list<boost::vecS, boost::listS, boost::bidirectionalS, Vertex, Edge, boost::no_property, boost::listS>, boost::detail::error_property_not_found, const boost::detail::error_property_not_found&, boost::vertex_index_t> >]' .../extern/boost/boost/graph/depth_first_search.hpp:297: instantiated from 'void boost::depth_first_search(const VertexListGraph&, const boost::bgl_named_params<P, T, R>&) [with VertexListGraph = GraphContainer, P = CycleDetector, T = boost::graph_visitor_t, R = boost::no_property]' applications/testGraph/src/main.cpp:77: instantiated from here .../extern/boost/boost/property_map/shared_array_property_map.hpp:36: error: no match for 'operator[]' in '((const boost::shared_array_property_map<boost::default_color_type, boost::adj_list_vertex_property_map<boost::adjacency_list<boost::vecS, boost::listS, boost::bidirectionalS, Vertex, Edge, boost::no_property, boost::listS>, boost::detail::error_property_not_found, const boost::detail::error_property_not_found&, boost::vertex_index_t> >*)this)->boost::shared_array_property_map<boost::default_color_type, boost::adj_list_vertex_property_map<boost::adjacency_list<boost::vecS, boost::listS, boost::bidirectionalS, Vertex, Edge, boost::no_property, boost::listS>, boost::detail::error_property_not_found, const boost::detail::error_property_not_found&, boost::vertex_index_t> >::data[boost::get [with PropertyMap = boost::adj_list_vertex_property_map<boost::adjacency_list<boost::vecS, boost::listS, boost::bidirectionalS, Vertex, Edge, boost::no_property, boost::listS>, boost::detail::error_property_not_found, const boost::detail::error_property_not_found&, boost::vertex_index_t>, Reference = const boost::detail::error_property_not_found&, K = void*](((const boost::put_get_helper<const boost::detail::error_property_not_found&, boost::adj_list_vertex_property_map<boost::adjacency_list<boost::vecS, boost::listS, boost::bidirectionalS, Vertex, Edge, boost::no_property, boost::listS>, boost::detail::error_property_not_found, const boost::detail::error_property_not_found&, boost::vertex_index_t> >&)((const boost::put_get_helper<const boost::detail::error_property_not_found&, boost::adj_list_vertex_property_map<boost::adjacency_list<boost::vecS, boost::listS, boost::bidirectionalS, Vertex, Edge, boost::no_property, boost::listS>, boost::detail::error_property_not_found, const boost::detail::error_property_not_found&, boost::vertex_index_t> >*)(&((const boost::shared_array_property_map<boost::default_color_type, boost::adj_list_vertex_property_map<boost::adjacency_list<boost::vecS, boost::listS, boost::bidirectionalS, Vertex, Edge, boost::no_property, boost::listS>, boost::detail::error_property_not_found, const boost::detail::error_property_not_found&, boost::vertex_index_t> >*)this)->boost::shared_array_property_map<boost::default_color_type, boost::adj_list_vertex_property_map<boost::adjacency_list<boost::vecS, boost::listS, boost::bidirectionalS, Vertex, Edge, boost::no_property, boost::listS>, boost::detail::error_property_not_found, const boost::detail::error_property_not_found&, boost::vertex_index_t> >::index))), ((void* const&)((void* const*)(& v))))]' .../extern/boost/boost/smart_ptr/shared_array.hpp:85: note: candidates are: T& boost::shared_array<T>::operator[](ptrdiff_t) const [with T = boost::default_color_type]

2 1

Re: [boost] [graph] out_edges sort
by fabien.castan＠free.fr 09 Sep '10

09 Sep '10

> There is no way to do a sort in place ? >> Not using the "official" interfaces, AFAIK. What are you trying to do? >> Maybe there's a different algorithm in BGL that might do what you want. I compute some values on each node, depending on connected vertices, etc. Next I need to visit my graph in a dfs but going first into out_edges with the biggest precomputed value.

2 1

Re: [boost] As a side note about source control
by Eric Hopper 09 Sep '10

09 Sep '10

Christoph Heindl wrote: > > As a side note, and I'm sure I'm opening a can of worms by even saying > > this... I find working on projects that do not use distributed source > > control to be really irritating nowadays. > > Could you explain why? What kind of projects (organizational structure). Well, the organizational structure of the project doesn't matter at all in my answer to the question. I will describe to you what I did with the Boost library in order to explain. I wanted to generate a whole ton of small random numbers quickly and found the smallint distribution. When I looked at the code, I was certain I could make something a lot faster that was very specific to my need, so I did, tested it and discovered that it was indeed much faster. Then I realized that by carefully using templates I could make it work for a much more general case. Now I want to make something that's a library module. I morph my special case into a more general case as a proof of concept. When that works, I then consider how to integrate the library module into Boost because that's where it belongs. There are lots of different versions of Boost that have been released and are installed on the various systems I work on. Not only that, but regardless of whether or not Boost ever accepts my changes I want to keep them locally so I will always be able to have a version of Boost with my changes. If I simply check out one of the tags for a version of Boost I have, I can certainly make my changes there, but I can never check them in or effectively track them against Boost itself as it moves forward. I could check out trunk, but trunk does not correspond to any version of Boost installed on my system and means I would be testing all kinds of changes that may or may not be ready for use. I'm not interested in being a Boost tester. And again, I really couldn't check my changes in or effectively integrate them with later versions of Boost. I eventually settle on doing an svn export of several successive versions of Boost and checking each into Mercurial. This is complicated by the need to undo Subversion's keyword replacement with a small perl script. And actually converting the Boost Subversion tree to Mercurial isn't very feasible because Subversion's idea of branching is so dissimilar. For example, there are a few cases of a tag being removed and replaced with a fresh copy of trunk, and this is very hard to model in any other source control system. Once I've done this conversion, things are pretty smooth. I can check in all my changes to my local Mercurial clone. I can play around with things, do code cleanup and various other things while still being able to track my source. I can also do development on my desktop and laptop and move changes smoothly between them even though the changes are checked in when the laptop may not be connected to the Internet. Later I discover Boost 1.44 has been released, so I repeat the process I used before to convert 1.44.0.beta1 and 1.44.0 to Mercurial revisions. Then I use Mercurial's merge feature to merge my changes back in. Poof, I have a version of Boost that has my changes, and I can publish a patch against Boost 1.44 as opposed to 1.43 if need be. If Boost had used a distributed version control system from the very beginning, that previous 6 paragraphs could've been condensed down to a couple of paragraphs. And future merges with Boost would generally be pretty trivial unless the random library changed significantly. This is true of any project I want to make a change to. I do not want to have to interact especially with the community for a one off change to a project I'm not really interested in becoming a regular contributor to. A centralized source system makes it hard to make changes except on active branches which frequently contain changes I'm not interested in testing. It makes it hard to track my changes locally regardless of the decisions of the community running the project. And it makes it hard to contribute a change back to the community when I don't want to become a full member, which in turn raises a barrier to entry to me being inexorably sucked into a community I didn't think I was going to participate in. All of these are regardless of the organizational structure of a project. They have everything to do with my ability to control and use the source code I download. Simply put, distributed source control is what fits the Open Source development model. I do not consider this an opinion so much as a flat statement of fact. The ability to fork is absolutely central to Open Source. It's harder to fork when you lose the history and ability to track changes against the original because a project's history and ability to track your changes to it is as important as a dump of the source code at a moment in time, if not more so. Distributed source control avoids these problems and makes forking easier, almost trivial. Distributed source control therefor fits the Open Source model better. In my opinion, distributed source control is the best fit for almost any development. But that's just my opinion, and I don't have nearly as much in the way of hard logical argument to back that up. I just know that I've used source control for nearly (and I'm rather embarassed that the word 'nearly' is there, but a 17 yr old in 1988 isn't likely to have heard of source control) as long as I've been a professional programmer. And distributed source control systems are the first source control systems I've used where I didn't feel like I was spending a lot of time fighting the source control system because it didn't work the way I needed it to. Discipline does not always require pain. -- A word is nothing more or less than the series of historical connotations given to it. That's HOW we derive meaning, and to claim that there is an arbitrary meaning of words above and beyond the way people use them is a blatant misunderstanding of the nature of language. -- Anonymous blogger -- Eric Hopper (hopper(a)omnifarious.org http://www.omnifarious.org/~hopper)--

5 4

Re: [boost] Status of FSM viewer
by Michal Sojka 09 Sep '10

09 Sep '10

Hi Andreas, thanks for the prompt answers. See my comments bellow. On Thu, 09 Sep 2010, Andreas Huber wrote: > > we are looking for a solution to visualize FSMs in our robotic > > applications. Before starting the development of our own tool I'd > > like to ask whether there exists something able to visualize > > Boost.Statecharts FSMs. > > No, as far as I know. > > > I was only able to find the > > following GSOC > > project: > [snip links] > > but in my quick tests it produced only empty figures. I > > believe that > > after some debugging I could make it work. > > Personally I wouldn't bother. IIRC, the project depends on GCC_XML, > the latest release of which is still 0.6, from 2004. There is activity > in source control but I'm not sure it has anything to do with the > tool. > > > My question is whether the development of this tool continues or > > whether there are some other tools. In case of negative answers, do > > you have any suggestions for the development of the new tool? > > Currently, we consider the development of a GCC plugin which will > > generate dot (graphviz) source. > > I don't know anything about GCC plugins, but I guess that is certainly > an option. Personally, I'd also check out clang, which presumably can > provide you with a much more C++-like representation of the parsed > source code. I had also thought about using clang but I was not able to compile even simple FSMs with it. I produced a lot of strange errors. I guess that clang's C++ support is not as mature as of GCC. Do you have more positive experience with clang++? > P.S. If you make your tool public, I'd love to be informed when you > have a first version to check out. Thanks! A student of mine will work on this in his bachelor thesis so the tool will definitely be public. If we have something that works, I'll let you know. Cheers, -Michal

4 3

[iostreams][1.44] file_descriptor constructor deprecated
by Hartmut Kaiser 09 Sep '10

09 Sep '10

Hey, Why has the iostreams::file_descriptor constructor taking a file descriptor (OS handle) being deprecated (BOOST_IOSTREAMS_USE_DEPRECATED)? This seems to be somewhat counter-intuitive to me. Even more as our code depends on this functionality and I see no way to rewrite it in order to accommodate for this change (we're wrapping a pipe handle here). The worst is that defining BOOST_IOSTREAMS_USE_DEPRECATED while compiling our application makes the compilation succeed, but linking fails as this function has not been compiled by default into the iostreams library. Regenerating the boost libraries is not an option for us, as we need to rely on pre-installed libraries most of the time (HPC systems have their own weird rules...). Any ideas? Regards Hartmut --------------- http://boost-spirit.com

2 2

[filesystem][v3] Fixed-size char array constructor
by Richard Hazlewood 09 Sep '10

09 Sep '10

The v3 path has a constructor/converter that takes a fixed-size char array. It uses the size of the array to determine the characters to use in the path. This can have unintended consequences for use cases like the following (common with Windows system calls): namespace bfs = boost::filesystem; bfs::path GetTemporaryPath() { // (Okay, it may be tidier to use allocated char* buffers for // these type of calls, but this approach is not unusual.) char buf[MAX_PATH]; GetTempPath(sizeof(buf) / sizeof(buf[0]), buf); return bfs::path(buf); //return bfs::path(&buf[0]); //work-around } The path that is returned contains all of the MAX_PATH characters, even though the system call does not fill all of these. It appears that the constructor assumes the array is null-terminated because it subtracts one. I presume this is to work with cases such as: char const buf[] = "mypath/myfile"; return bfs::path(buf); However, the null-terminator may not be the last char, as in the case given.

1 0

Status of FSM viewer
by Andreas Huber 09 Sep '10

09 Sep '10

Hi Michal > we are looking for a solution to visualize FSMs in our > robotic > applications. Before starting the development of our own > tool I'd like > to ask whether there exists something able to visualize > Boost.Statecharts FSMs. No, as far as I know. > I was only able to find the > following GSOC > project: [snip links] > but in my quick tests it produced only empty figures. I > believe that > after some debugging I could make it work. Personally I wouldn't bother. IIRC, the project depends on GCC_XML, the latest release of which is still 0.6, from 2004. There is activity in source control but I'm not sure it has anything to do with the tool. > My question is whether the development of this tool > continues or whether > there are some other tools. In case of negative answers, do > you have any > suggestions for the development of the new tool? Currently, > we consider > the development of a GCC plugin which will generate dot > (graphviz) > source. I don't know anything about GCC plugins, but I guess that is certainly an option. Personally, I'd also check out clang, which presumably can provide you with a much more C++-like representation of the parsed source code. HTH, -- Andreas Huber When replying by private email, please remove the words spam and trap from the address shown in the header.

1 0

[graph] dfs depending on VertexList container
by fabien.castan＠free.fr 09 Sep '10

09 Sep '10

Hi, We can't use the easiest syntax of dfs, if we use another container than vecS as VertexList container. boost::depth_first_search( graph, boost::visitor( vis ) ); So the only way is to initialize the colormap ourself and give it to the depth_first_search function. The problem is that the dfs use operator[]. I looked at the code and if I understand correctly, it seems that this operator is only use to init the colormap. Best regards, Fabien Castan

3 3

[graph] out_edges sort
by fabien.castan＠free.fr 09 Sep '10

09 Sep '10

Hi, I would like to visit my graph in a particular order using a dfs visitor. To do this I tried to order the out_edges of each node. I use the std sort function, like this: GraphContainer::out_edge_iterator oe_it, oe_itEnd; boost::tie( oe_it, oe_itEnd ) = boost::out_edges( vd, graph ); std::sort( oe_it, oe_itEnd, OrderEdge<GraphContainer>(graph) ); But it does nothing. It seems that there is an empty operator= on out_edge_descriptor. So, how can I sort the out_edges ? Best regards, Fabien Castan

3 3

What about a Spirit-powered C++ syntax analysis library in Boost?
by Florian Goujeon 08 Sep '10

08 Sep '10

Hi Boosters, I've written a C++ syntax analysis library using Boost.Spirit. (This 'library' is actually a subset of the Scalpel library. I talked about it in the Boost mailing list here: http://article.gmane.org/gmane.comp.lib.boost.devel/208217 ) For the sake of brevity, let's call it Salsa (for Stand-ALone Syntax Analysis). While most C++ compilers need semantic information to perform the syntax analysis, Salsa is a standalone syntax analyzer. Its Spirit grammar doesn't run any semantic action. Consequently, you can use it to parse some C++ code without having to analyze a whole translation unit (i.e. without processing #include directives). At this point, you may wonder how syntax ambiguities are managed. In most cases, there's always an interpretation which is more obvious than the other one(s). In all cases, you may reasonably ask the programmer to disambiguate its code. Whatever the case, Salsa (predictably) chooses one of the interpretations. Here are some examples: The following statement…: a * b; … may be either a multiplication or a pointer declaration. The default interpretation is the pointer declaration. You can reasonably ask the programmer to disambiguate the code by putting parenthesis if he wants the syntax analyzer to interpret it as the former: (a * b); Trickier. In the following declaration…: bool bool_ = a< b || c> (d&& e); … the right-hand side expression may be either a boolean expression (where 'a', 'b', 'c', 'd' and 'e' are variables of type bool) or a function template call (whose name is 'a', which takes one bool template parameter and where 'b', 'c', 'd' and 'e' are all variables of type const bool). The default interpretation is the boolean expression. Once again, you can reasonably ask the programmer to disambiguate the code by putting parenthesis if he wants Salsa to interpret it as the latter: bool bool_ = a< (b || c)> (d&& e); (Actually, I wonder why the standard allows such ambiguities.) Note: Salsa isn't finalized yet, but it successfully parses Apache's implementation of the C++ standard library. I'd like to know: is there a reasonable chance that such a library will be accepted into Boost?

3 2