November 2004 - Boost - lists.preview.boost.org

Boost Iterable Range Library update (v1.5)
by John Torjo 12 Nov '04

12 Nov '04

Dear boosters, I have updated the Iterable Range Library (formely known as Range Templates Library). It makes dealing with containers/STL algorithms simpler by using ranges (as opposed to iterators). Simply put, a range is a smarter std::pair<iterator,iterator>. Here's a taste: for ( crange<some_array_type> r(some_array); r; ++r) do_something( *r, some_data); Also, the library provides wrappers for all STL algorithms (for the purpose of STL algorithms, all containers are ranges as well): typedef std::vector<std::string> word_array; word_array v; // STL version std::copy( v.begin(), v.end(), print); // rng:: version rng::copy( v, print); Also, the counterparts for STL algorithms that return an iterator will return a range, allowing for: // fill a vector with all the indexes at which a certain string is found std::string str = "I'm a cool programmer, really cool that is", find = "cool"; std::vector<int> result; crange<std::string> r(str); while ( r = rng::search(r, find)) result.push_back ( r.begin() - str.begin() ); And it provides for range adaptors, allowing for composition. bool from_ro(const employee & e) { return e.country == "Romania"; } std::string get_empl_name(const employee &e) { return e.name; } typedef std::vector<employee> array; array empls; // take all employees from Romania, and print their names rng::copy( transformed( filtered(empls,from_ro), get_empl_name), std::ostream_iterator<std::string>(std::cout," ")); Changes in this version: - improved algorithms.hpp (no more use of macros) - solved small bugs - added documentation Download it from here: http://www.torjo.com/rangelib/ Feedback is welcome. Best, John -- John Torjo, Contributing editor, C/C++ Users Journal -- "Win32 GUI Generics" -- generics & GUI do mix, after all -- http://www.torjo.com/win32gui/ -- v1.5 - tooltips at your fingertips (work for menus too!) + bitmap buttons (work for MessageBox too!) + tab dialogs, hyper links, lite html

10 27

Re: Generalised reflection
by George van den Driessche 12 Nov '04

12 Nov '04

> Message: 4 > Date: Fri, 12 Nov 2004 07:34:27 -0500 > From: "Neal D. Becker" <ndbecker2(a)verizon.net> > Subject: [boost] Re: Generalised reflection > To: boost(a)lists.boost.org > Message-ID: <cn2akj$qij$1(a)sea.gmane.org> > Content-Type: text/plain; charset=us-ascii > > George van den Driessche wrote: > > [...] > > Yes. Now imagine that I've got some helper functions for use with > > Boost.Python's pickling suite. But I want to use them with a C++ > > serialisation library. I'm going to have to factor a bunch of code out of > > those helper functions so that I can invoke them without using > > boost::python::tuple, and then write wrappers to use the factored-out code > > with the Boost.Python pickling suite. Instead, I want to write just the > > C++ serialisation code, and have that automatically wrapped up for use > > with Boost.Python pickling. It's a similar separation of layers. > > > > Incidentally, I wrote about sharing boost c++ serialization with > boost.python pickling, and posted code demonstrating this. Nobody seemed > very interested. I think it's this post: http://tinyurl.com/6dbhb that you're referring to. In which case, I missed it, but yes, you're on the same topic. One of the things that I noticed about serialisation code is that there's generally a symmetry between the reading and writing routines. So rather than write "this is how I load an X, and this is how I save one" I'd want to write "these are the things in X that need to be saved" and let some templates figure out what the corresponding routines are. And then it was this desire to serialise things automatically by specifying properties that led me on to think about a common architecture for language binding and serialisation. Maybe in the end you'd get declarations like: /// Properties for serialisation boost::properties< my_t, "my_t", boost::serialisation > .def( "my_int", &my_t::my_int, &my_t::set_my_int ) // After serialisation format version 4, // my_float no longer needed to be serialised .def( "my_float", &my_t::my_float, &my_t::set_my_float, boost::serialisation::in_format_version_range<>( 0, 4 ) ) ; /// Properties for scripting boost::properties< my_t, "my_t", boost::langbinding > // Use serialisation properties to implement pickling. .def_pickle( default_pickle_suite< my_t >() ) .def( "my_int", &my_t::my_int, &my_t::set_my_int, boost::langbinding::return_internal_reference<>() ) // We don't want to bind my_float, for whatever reason. ;

2 1

RE: [boost] [Review] Named parameters library
by Aleksey Chernoraenko 12 Nov '04

12 Nov '04

Hello, >[...] > http://groups.yahoo.com/group/boost/files/named_params.zip Is it possible to make a copy to somewhere else, more accessible place (http://sourceforge.net/projects/boost/) ? ---- Thank you, Aleksey Chernoraenko

3 2

[library process] should we more actively pursue university thesis projects?
by Thorsten Ottosen 12 Nov '04

12 Nov '04

Dear all, Following our discussion of the unicode library, would it not be a good idea to persue such efforts more aggresively? I could imagine it would help bring forward libraries much faster. I think it would be reasonable that the boost comunity provided 1. project descriptions 2. help and guidelines throughout the 6-12 months of the project If we had small papers explaining potential projects, these can be sent to universities which can the in turn suggest them to their students. Off the top of my head, I can think of these projects 1. C++ database library 2. C++ statistics library 3. exact reals class 4. An XML parser and generator library I could probably be a co-author and contact person of (2). Any thoughts? -Thorsten

4 4

logging lib, v1.3
by John Torjo 12 Nov '04

12 Nov '04

Dear boosters, Finally, have had some time to update the logging lib. Get it from: http://www.torjo.com/ (of course, it comes packed with docs) First of all, many thanks to Darryl Green and Caleb Epstein! Summary - solved a few bugs - redesigned so that I allow for scoped logs (no more log IDs, now logs are identified by a 'string name') - ported the code from Caleb - allow for a "log manager" (many thanks to Darryl Green!) (it is not documented yet, but will do so as soon as I have some time) - updated docs - (renaming) add_modifier_func -> add_modifier (renaming) add_logger_func -> add_appender - thread-safety update (again, many thanks to Darryl Green!) - you can log messages even *before* logs are initialized after logs are initialized, just call flush_log_cache(); As for scoped logs, to make a long story short, you'll be able to do: logger gui("app.gui") if (gui) gui.stream() << "something GUIsh"; // or (equivalent) BOOOST_SCOPEDLOG(gui) << "something GUIsh"; Still to do: - docs: write about log managers - cyclic logs Looking forward to your feedback! Best, John -- John Torjo, Contributing editor, C/C++ Users Journal -- "Win32 GUI Generics" -- generics & GUI do mix, after all -- http://www.torjo.com/win32gui/ -- v1.5 - tooltips at your fingertips (work for menus too!) + bitmap buttons (work for MessageBox too!) + tab dialogs, hyper links, lite html

11 47

boost::weak_ptr
by Dirk Gregorius 12 Nov '04

12 Nov '04

Is it possible to reset a boost::shared_ptr without all associated boost::weak_ptr become invalid? -Dirk

2 1

boost::function feature request?
by Peter Dimov 12 Nov '04

12 Nov '04

When using boost::function<bool()> to implement event callbacks such as is_visible or is_enabled, it's very convenient to pass 'true' or 'false' directly, instead of going through bind( identity<bool>(), true ). An UI button I recently did even had separate bool properties in addition to the callback events for these reasons. I wonder whether it's reasonable to add this_type& operator=( T const & t ); to function<T()> that does the obvious thing. Of course f = t; is merely a shorthand way of spelling f = boost::lambda::constant(t), but a dependency on lambda isn't always desirable. Thoughts? -- Peter Dimov http://www.pdimov.com

4 10

Re: Generalised reflection
by George van den Driessche 12 Nov '04

12 Nov '04

> Message: 4 > Date: Thu, 11 Nov 2004 17:08:53 -0500 > From: David Abrahams <dave(a)boost-consulting.com> > Subject: [boost] Re: Generalised reflection > To: boost(a)lists.boost.org > Message-ID: <uoei4kphm.fsf(a)boost-consulting.com> > Content-Type: text/plain; charset=us-ascii > > "George van den Driessche" <grebe(a)bigfoot.com> writes: [snip] > > Yes, but in Boost.Python you're really saying two things for each type: > > (a) Here's my type's internal structure. > > Emphatically no. In Boost.Python you describe a new Python type's > public interface. Its interface doesn't have to have any relationship > to that of the C++ type. > > > (b) Here's how to present the internal structure to Python. > > I think this fact is slightly disguised because the two steps are both > > performed by the def() function. > > Believe me, I understand that there are two things happening there, > and the Langbinding project aims to separate those two things. But > when doing language binding you are definitely *not* describing > internal structure. The two things are: > > i. Describe the external interface to the new type. > ii. Turn that interface description into an actual Python type. Yes. I shouldn't have used the phase 'internal structure' here. A better indication of what I'm getting at comes later in my message, but was cut from your reply: > > What I'm suggesting amounts to factoring out the common first step. Let's > > suppose that we do in fact have a general reflection library, which allows > > you to list the properties of your class and attach arbitrary bits of data > > to them. So allow me to revise the description of the two stages: (a) Enumerate the runtime-accessible properties of a C++ type and associate names with them. (b) Turn that interface description into an actual Python type. > > But the fact that it takes > > pointers-to-members is a giveaway. > > The fact that you are generally binding member functions (and only > public ones) is also a dead giveaway. What Rene said may be true > (that most types can be serialized and reconstructed through their > public interface), but it's not a foregone conclusion. I agree. In the case where you need to provide two different reflections, you write two different descriptions. In the common case where you can use the same one for both purposes, you've saved yourself a bunch of work. This is just the same as Python providing default pickling support to cover the common cases - you still have to customise it sometimes, but it does the bulk of the work for you. > > Part (b) here corresponds to the extra > > data that you attach to exposed members, such as return_internal_reference. > > In a serialisation library, you're saying two things too: > > (a) Here's my type's internal structure. > > (b) Here's how to write the structure to a file, and read it back. > > In fact, if your classes are appropriately exposed to Python, you could just > > pickle them in Python and you'd be done. > > *If* they expose enough information to be picklable. >>> And note > that Boost.Python has explicit support for pickling, which rather > strongly hints that the information you supply it for ordinary class > wrapping is usually not sufficient for serialization. <<< Yes. Now imagine that I've got some helper functions for use with Boost.Python's pickling suite. But I want to use them with a C++ serialisation library. I'm going to have to factor a bunch of code out of those helper functions so that I can invoke them without using boost::python::tuple, and then write wrappers to use the factored-out code with the Boost.Python pickling suite. Instead, I want to write just the C++ serialisation code, and have that automatically wrapped up for use with Boost.Python pickling. It's a similar separation of layers. > > Maybe it would help to describe how I arrived at the idea I'm > > suggesting. > > No offense, but probably not; you're not the first one to think that > the ideas behind Boost.Python could be used to build a generalized > reflection library. Of course not. However, since you agree with my premises but you disagree with my conclusion, it follows that you must disagree with my reasoning at some stage. So by describing my reasoning, I'm hoping that you'll be able to pinpoint that stage and then we can discuss that instead :) > If you search this mailing list's history and > that of the Python C++-sig I think you'll find some other > conversations along these lines. It's a fine idea; I just have a > hard time believing that the information you need to expose for > serialization is normally the same as what you need to expose for > language binding. Maybe the same front-end interface code can be > used to do the exposing, but whatever the user writes for one is not > going to magically work for the other. I completely agree. In my message I did write: > > The major architectural problem I foresee with hanging different categories > > of information (scripting, serialisation, UI &c) off the same reflection > > objects is that people might want to define how to serialise an object in > > one place, but how to script it in another. Now, even if this cannot be resolved, the many reflection-based tasks still have a common step (a), namely building a reflection of a type. You can find yourself providing several reflections of a type for different purposes, but nonetheless the mechanism of reflection is the same: bind properties to names. In other words, even if you must have different reflections of a type for different purposes, the means of generating those reflections is the same, and the underlying structure of each reflection is the same. (Note: I'm *not* saying here that each reflection reflects the same properties of the type, but that each reflection is a set of tuples of (name, property, reflection-specific-extra-data.) So one could factor out the definition of the reflection structure. What does one gain from that? Well, in the cases where you really could use the same reflection for several purposes, you only need to provide one (as in the Langbinding case). In other cases, you write several reflections, but they all use the same syntax (probably similar to boost::python::class_ definitions) which means: i) you can plug the same helper/accessor functions into any of them. ii) if you can read one, you can read them all. George

2 1

Can anyone please give me advice on regression test building?
by Roland Schwarz 12 Nov '04

12 Nov '04

This is my second attempt to get some help on regression test build. If I should post this to another list, please anyone give me advice to where I should post instead. Here is my question: I try to invoke bjam in subdirectory .....\boost\status (After having set TOOLS=vc-7_1 ) The last line I see is: Unknown suffix on <@boost!libs!spirit!test>./select_p_with_rule.cpp<template>normal - see UserObject rule in Jamfile(5). Obviously nothing has been built (no tests have been run?) Is this an error in the test Jamfile of spirit, or am I trying to do something stupid? Thank you for any help on this. Roland

2 3

boost::shared_ptr: Changing raw pointer for all instances
by Dirk Gregorius 12 Nov '04

12 Nov '04

My boost::shared_ptr objects hold pointees to interfaces. It might happen that these raw pointees might become invalid or that I like to change the implementation. Is it possible to change the raw pointee of all boost::shared_ptr objects in an application due to some kind of event? Example: I have one singleton class that provides several factory functions: class Factory { public: boost::shared_ptr<IFoo> CreateX( void ); // ... more factory functions private: // Events - void OnChangeImplementationX( void ); // Data members typedef std::vector< boost::shared_ptr<IFoo> > MasterColl; MasterColl m_FooObjects; } boost::shared_ptr<X> Factory::CreateX( void ) { // Create a new foo object boost::shared_ptr<IFoo> pFoo( new FooImpl ); // Save a "master" instance m_FooObjects.push_back( pFoo ); // Return the object return pFoo; } void Factory::OnChangeImplementationX( void ) { // Iterate over all "master" objects and change the underlying pointee } Can this be implement using the boost::shared_ptr class? Regards, -Dirk

1 0