- Boost - lists.boost.org

[1.49.0] Schedule finalized
by Beman Dawes 08 Dec '11

08 Dec '11

The 1.49.0 schedule has been posted to the Boost C++ Libraries calendar. Milestones (all dates are Mondays): December 19: 1.49.0 (I.E. branches/release) Closed for new libraries. December 26: Quality checks begin January 9: Closed for major changes January 16: Closed for all changes January 23: Beta target date February 20: Release target date The longer period between the beta and release is intended to allow more time to respond to problem reports. --The Release Team

1 0

[msm] deferral stack overfolw
by Richard Szabo 08 Dec '11

08 Dec '11

Hi Christophe just playing around with event deferral I have found a problem which leads to a stack overflow it ends in an infinite loop if I want to defer 2 events in the same state. see attached example it somehow similar to the problem we had earlier but that was fixed ... I have ran this test on MSM trunk version from yesterday. Cheers Richie

2 8

[build] Little help required
by Antony Polukhin 08 Dec '11

08 Dec '11

Hi, I need to create Jamfile.v2 where one of the tests must be compiled on MSVC compilers with additional flag /Zc:wchar_t- How shall I change the following lines: test-suite conversion : # A lot of [ run ... ] lines [ run lexical_cast_typedefed_wchar_test.cpp ../../test/build//boost_unit_test_framework/<link>static ] # Requires /Zc:wchar_t- ; Best regards, Antony Polukhin

2 4

Re: [boost] Boost.Math and Math Constants
by Brent Spillner 08 Dec '11

08 Dec '11

On Wed, 7 Dec 2011 15:33:21 Paul A. Bristow wrote: >John Maddock has now added a new cunning feature that allows the vast majority of users who just >want a built-in double to get the constants quickly as plain variables. So in non-template code, >users can write > > using boost::math::double_constants; > double area = pi * r * r; > >and users can read the equations easily. > >(Float and long double are similarly available in their own namespaces). It's a little bit of work up front, but if you define a custom type with separate overloads for each arithmetic operator/operand type combination (i.e. *(float), *(double), +(float), +(double), etc.) you should be able to offer a single namespace with constants that auto-promote (or demote) to the right type in expressions. That's also easily extensible to user-defined storage classes such as an extended precision float, and I think it's more maintainable since the using declaration (which is now untyped) can't get out of sync with the usage context. To prevent ambiguous overloads (in contexts where the constant itself is supplied as an argument to a polymorphic function, not in expressions), you can leave just one type (perhaps double) as implicitly castable-to, with explicit casts for the others. That seems more Boost-y to me, at any rate.

4 3

[stl_ext_adv] ] Interest in advanced data structures
by Vadim Stadnik 08 Dec '11

08 Dec '11

Hi all, Advanced data structures (ADS) offer useful STL extensions that are not possible or not efficient with basic data structures, such as arrays, linked lists and red-black trees. The project https://github.com/vstadnik/stl_ext_adv http://dl.dropbox.com/u/51041088/stl_ext_adv_doc/index.html focuses mainly on a generalized and unified computer representation of sequences using the augmented B+ trees. It provides the following STL extensions: - The sequence container supports random access iterators and a union of interfaces of STL containers: vector, list and deque. This sequence offers the advantage of efficient update operations with logarithmic running time compared with linear running time of the same operations of std::vector. - The associative containers (set, multiset, map and multimap) with random access iterators. - The enhanced random access iterators effectively address the fundamental problem of the iterator invalidation. - The function accumulate() with logarithmic computational complexity can significantly improve performance of many practically important algorithms and applications, such as the numerical integration, the statistics, the data analysis etc. The examples demonstrate how to improve the computational complexity from O(N) to O(log N) in the following applications and problems: - numerical integration. - calculation of mean value and standard deviation; - calculation of weighted mean value; - testing if any number of consecutive elements are equal; - counting intersections of one interval with sequence intervals; Is there an interest in this project and implemented STL extensions? Interest in potentially useful, but not yet implemented algorithms and specialized containers: 1. The function accumulate() with constant computational cost. With this function some user algorithms, such as the numerical integration, can come close to the absolute theoretical limit of the computational cost. The function can be implemented through iterators enhanced with functionality of accumulators. For more details, see the section “Random access iterators” in the documentation. 2. The functions sequence::splice() with logarithmic running time in the worst case. Note that functions std::list::splice() provide in many cases constant computational cost, however, in the worst case the cost is linear. 3. Any other potentially useful specialized containers, iterators or algorithms? Augmented B+ trees are versatile and powerful data structures. They can be designed to maximize efficiency of particular algorithms and programming solutions. The limitation of specialized containers is that the computational cost of some other operations may increase. About augmented red black trees. The augmented red black trees can also support various STL extensions. The red black trees are yet out of the scope of this project for the reasons explained in the documentation. However, historically augmented red-black trees are probably the first ADS that could extend STL, since the method of augmenting red black trees was described as early as in 1990 [T.H. Cormen, C.E. Leiserson and R.L. Rivest.” Introduction to Algorithms” (1st ed.). MIT Press and McGraw-Hill, 1990]. This means, in particular, that the very first version of STL could provide associative containers with random access iterators. Also, as I understand the previously submitted project https://github.com/boost-vault/Containers/blob/master/countertree.zipimplem… containers based on the augmented red black trees. It is hardly possible to make an exact prediction, but without a doubt future versions of STL will benefit from advanced data structures. Regards, Vadim Stadnik

11 29

boost.heap in trunk
by Tim Blechmann 07 Dec '11

07 Dec '11

hi all, i've imported my boost.heap library into trunk. it currently won't compile with gcc, but i've submitted patches against boost.parameter [1] and boost.fusion [2]. i hope they are applied, soon. i managed to integrate it into the documentation system, but it still needs to be integrated into the bug tracker and the regression test system. can i do that myself? tim [1] https://svn.boost.org/trac/boost/ticket/6214 [2] https://svn.boost.org/trac/boost/ticket/6215

3 2

Re: [boost] c++11 and gcc 4.7
by Leo Goodstadt 07 Dec '11

07 Dec '11

> > From: Bruce Adams <tortoise_74(a)yahoo.co.uk> > Date: Tue, 6 Dec 2011 19:08:56 +0000 (GMT) > > Hi, > I am attempting to do a cost benefit analysis to justify adopting the > subset of C++11 that is supported by gcc 4.7. > As threads are one of the biggest features of c++11, I may be asked to > justify just boost.thread vs > gcc 4.7 + boost.thread. You may also wish to consider using a higher level threading library on top of std::thread / boost::thread. We have been using Intel Threading Building Blocks (http://threadingbuildingblocks.org/) for a while now, and it seems to live very happily alongside Boost. TBB means that you don't have to roll your own thread pools, or adjust the parallelism each time your programme is run. It is also a very thin layer in terms of efficiency. The modern trend across many programming languages also seems to move away from using (manual) synchronisation primitives whenever possible (just as "raw" new and delete has become rare in c++ over the past 20 years). TBB allows complex pipelines to be supported quite naturally in terms of a data flow. My only reservation is that it requires dynamic linking, which is not always desirable or even possible. Finally, the extra level of abstraction in TBB probably means that the onus on supporting varying standards of c++ 11 conformance falls on Intel and not you or your company! Leo

1 0

Is there any interest in a library which solves C++ class reflection feature just like Java does?
by jinhua luo 07 Dec '11

07 Dec '11

Hi, In brief, I'd designed and implemented somehow C++ class reflection based on boost libraries. It has some unique advantages: a) it doesn't require code generator b) platform independent and compiler independent (I tested it on Windows and Linux, with vs2008 and gcc respectively) c) it's non-intrusive for the class definition, instead, you just need to declare and describe your class via some straightforward macros anywhere (header file or source file, and may be within any namespace), which also means you can wrap an external third-party library (which you have no way to touch the source codes) and reflects it classes. d) Cross shared library boundary, you can dynamic load the shared library and reflect the classes within it, without need to export any symbol manunally in C wrapper function way e) the API looks like Java reflection API Below is some codes snippet to have an overview of this library: -----libTest.cpp---start--- #include <iostream> #include <string> #include <boost/reflection/reflection.hpp> namespace test { class AccountItf { public: virtual std::string getId() const = 0; virtual void setId(std::string id) = 0; }; #define ACCOUNT_INTERFACE_REFL_DECLARE \ BOOST_REFL_INTERFACE(test::AccountItf) \ BOOST_REFL_CONST_METHOD(getId, std::string()) \ BOOST_REFL_METHOD(setId, void(std::string)) class Account : public AccountItf { std::string id; public: Account() : age(0) {} Account(std::string id, unsigned int age) : id(id), age(age) {} static void echo(Account* acct, std::string banner) { std::cout << banner + ": " << acct->getId() << std::endl; } std::string getId() const { return id; } void setId(std::string id) { this->id = id; } public: unsigned int age; }; //Account declaration for used by reflection //this declaration can be placed anywhere, even the header file BOOST_REFL_CLASS ( (test)(Account), //constructors BOOST_REFL_CONSTRUCTOR() BOOST_REFL_CONSTRUCTOR(std::string id, unsigned int age) //static methods BOOST_REFL_STATIC_METHOD(echo, void (Account* acct, std::string banner)) //properties BOOST_REFL_PROPERTY(age, unsigned int) //derived Inteface ACCOUNT_INTERFACE_REFL_DECLARE ) } -----libTest.cpp----end-- Compile the libTest.cpp into the libTest.dll or libTest.so. -----main.cpp----start-- #include <iostream> #include <string> using namespace std; #include <boost/reflection/reflection.hpp> using namespace boost::reflection; #if defined(BOOST_WINDOWS) #include <Windows.h> #else #include <dlfcn.h> #endif int main(int argc, char* argv[]) { #if defined(BOOST_WINDOWS) LoadLibraryA (argv[1]); #else dlopen(argv[1], RTLD_NOW); #endif Class t = Class::forName("test.Account"); boost::any obj = t.newInstance(std::string("Account-id-100"), (unsigned int)26); t.invokeStatic("echo", obj, std::string("TEST")); TypeInfoArray tArray; tArray.push_back(BOOST_REFL_TYPEID(std::string)); Method m1 = t.getMethod("setId", tArray); m1.invoke(obj, std::string("Account-id-200")); Method m2 = t.getMethod("getId"); boost::any ret = m2.invoke(obj); std::cout << "Account getId(): " << boost::any_cast<std::string>(ret) << std::endl; Property prop = t.getProperty("age"); prop.set(obj, (unsigned int)30); std::cout << "Account age: " << boost::any_cast<unsigned int>(prop.get(obj)) << std::endl; return 0; } -----main.cpp---end--- Compile the main.cpp into the executable and execute it: ./main libTest.dll it will output: TEST: Account-id-100 Account getId(): Account-id-200 Account age: 30 This library is very useful for framework-level design which needs C++ reflection, e.g. recently I'm working on somehow SQL mapping library for C++, just like MyBatis, and reflection makes possible to invoke the getter/setter of the object instances of classes specified in the XML file. Regards, JinHua

8 25

c++11 and gcc 4.7
by Bruce Adams 06 Dec '11

06 Dec '11

Hi, I am attempting to do a cost benefit analysis to justify adopting the subset of C++11 that is supported by gcc 4.7. I believe there is a strong case for doing so from just the minor features and library improvements. However, I am having a hard time putting together a convincing cost benefit analysis (actually I would like to be able to do this with parts of boost too - any help with this would be great). I have many subjective arguments for boost, C++11 and TR1 but am tasked with trying to justifying any change in terms of costs and benefits. One of Boost's roles is to fill in gaps in c++ support where compiler vendors have not yet provided an implementation. I know that g++4.7 has incomplete support for multi-threading but it is unclear whether this is in the core language area and/or library area and what platforms it applies to. I am specifically interested in GNU/Linux. The status of boost for gcc4.7 is unclear (I know it has not been officially released yet but the status for gcc 4.6.2 is also unclear). Both of the following links from www.boost.org are several years and versions out of date http://www.boost.org/doc/libs/1_34_0/status/compiler_status.html http://boost.sourceforge.net/regression-logs/ Will boost.thread work as a drop in replacement for std::thread or is anything missing or broken on the core language side? (On the gcc side I am also interested in whether std::thread is a sufficiently complete implementation of the standard that boost.thread might not be necessary). The answer to this question may make my work harder. I was asked to justifiy either TR1, some part of boost or C++11 as my preference. I opted for C++11 as the most useful. I would probably have to justify boost libraries on a case by case basis. Justifying use of C++11 actually amounts to justifying a compiler upgrade + possibly training + possibly boost.thread As threads are one of the biggest features of c++11, I may be asked to justify just boost.thread vs gcc 4.7 + boost.thread. Surprisingly another thing that is unclear is the exact set of boost libraries that were included in C++11. I don't have either the standard (other than the February draft http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2011/n3242.pdf) or a good summary of the standard to hand. Suprisingly neither the boost website nor the g++ page have a list either, though the following two links are helpful: http://www.boost.org/doc/libs/1_48_0/?view=filtered_std-tr1 http://www.boost.org/doc/libs/1_48_0/?view=filtered_std-proposal I found a reference somewhere online (that I can no longer find) claiming, I believe incorrectly, that boost file_system is in C++11. This isn't mentioned on: http://www.boost.org/doc/libs/1_48_0/libs/filesystem/v3/doc/index.htm But nor its is presence in the 2005 "TR2" proposal. I worry that the 2005 TR2 proposal may be confused with any real TR2 proposal following on from C++11. I note that boost.chrono claims to be implemnting C++11 but I would have thought it was other way around and that the boost library was incorporated into the standard. http://www.boost.org/doc/libs/1_48_0/doc/html/chrono.html Anyway, the closest I've come to a list of libraries in C++11 outside of n3242 is: http://www2.research.att.com/~bs/C++0xFAQ.html#library Regards, Bruce.

3 2

Re: [boost] Is there any interest in a library which solves C++ class reflection feature just like Java does?
by Brian Wood 06 Dec '11

06 Dec '11

Matus Chochlik on Tue, Dec 6, 2011 at 2:40 AM, jinhua luo <ljh.home.king(a)gmail.com> wrote: > Hi, > Hi, >> It has some unique advantages: >> a) it doesn't require code generator > Good, but it is not so unique Because C++ compiler is a code generator? [ ...] >> d) Cross shared library boundary, you can dynamic load the shared library >> and reflect the classes within it, without need to export any symbol >> manunally in C wrapper function way > I believe (and I have some expertise in using and implementing reflection > in C++ to base that belief upon) that the basic reflection should > compile-time and any run-time reflection should be built on top > of that. Agreed. -- Brian Wood Ebenezer Enterprises http://webEbenezer.net <http://webebenezer.net/> (651) 251-9384

1 0