August 2011 - Boost - lists.preview.boost.org

How to use BCP
by William Voorhees 17 Aug '11

17 Aug '11

I'm updating a small C program to take in a options from either environment variables, or a config file and having long heard of boost as a great resource decided to give the program_options module a try. Since the utility is small and I don't have any current plans for other boost functionality it doesn't make sense to include the full BOOST library, so I tried to use bcp to get only the files I'm interested in. I was able to get a subset of boost code that I should be able to use with bcp, however I don't know how to compile the program_options library for linking in my code. >From a bit of googling it looks like bjam is the build tool, but it doesn't seem to be included with the subset of files I have. How would I go about incorporating boost so that all of the necessary source and associated utilities are included for an end user to build from. I should be able to issue a series of simple commands (looks like ./bootstrap.sh and make) to build and install my library with statically linked in boost. -Will Voorhees

3 5

Re: [boost] [Containers Library Review] The review of the Containers library by Ion Gaztanaga starts today
by Ion Gaztañaga 17 Aug '11

17 Aug '11

El 17/08/2011 12:20, Diederick C. Niehorster escribió: > Some performance tests might be nice here too (and the code for > generating them should be incorporated in the distribution), comparing > to std:: libraries shipped with the popular compilers. It'll help sell > your library and it'll serve as a nice benchmark later as vendors > update their standard library implementations. At least, I'd be > interested in such information and if test code is avaiable, I could > easily run the testcases myself. This is a good idea, but it'd require a huge amount of work if we think about an extensive benchamark framework. Maybe some basic tests?

1 0

[Containers Library Review] The review of the Containers library by Ion Gaztanaga starts today
by John Maddock 17 Aug '11

17 Aug '11

The review of the containers library by Ion Gaztanaga starts today, to summarize the library: "Boost.Container library implements several well-known containers, including STL containers. The aim of the library is to offers advanced features not present in standard containers or to offer the latest standard draft features for compilers that comply with C++03. In short, what does Boost.Container offer? * Move semantics are implemented, including move emulation for pre-C++0x compilers. * New advanced features (e.g. placement insertion, recursive containers) are present. * Containers support stateful allocators and are compatible with Boost.Interprocess (they can be safely placed in shared memory). * The library offers new useful containers: o flat_map, flat_set, flat_multiset and flat_multiset: drop-in replacements for standard associative containers but more memory friendly and with faster searches. o stable_vector: a std::list and std::vector hybrid with random-access iterators that offers iterator stability in insertions and erasures. o slist: the classic pre-standard singly linked list container." Documentation from the library may be viewed online here: file:///M:/data/boost/sandbox/move/libs/container/doc/html/index.html The source may be accessed from the "move" directory of the sandbox SVN or downloaded from http://www.drivehq.com/web/igaztanaga/boost_container.zip. Note that this download contains a copy of the accepted, but not yet release, Boost.Move library - extract the zip over a copy of Boost-1.47 to get a full working copy. Review comments might like to answer the following questions: * What is your evaluation of the design? * What is your evaluation of the implementation? * What is your evaluation of the documentation? * What is your evaluation of the potential usefulness of the library? * Did you try to use the library? With what compiler? Did you have any problems? * How much effort did you put into your evaluation? A glance? A quick reading? In-depth study? * Are you knowledgeable about the problem domain? And finally, every review should answer this question: * Do you think the library should be accepted as a Boost library? Be sure to say this explicitly so that your other comments don't obscure your overall opinion. Regards, John Maddock.

10 18

Re: [boost] [containers review] A reminder that the containers review ends tomorrow
by John Maddock 17 Aug '11

17 Aug '11

The containers library review is now officially over. However, there are still a few drips a drabs of reviews coming in.... are there any more still pending? Thanks, John.

3 2

Re: [boost] [gsoc] Request Feedback for Boost.Ustr Unicode String Adapter
by Stewart, Robert 16 Aug '11

16 Aug '11

Yakov Galka wrote: > On Fri, Aug 12, 2011 at 15:04, Matus Chochlik > <chochlik(a)gmail.com> wrote: > > On Fri, Aug 12, 2011 at 1:08 PM, Yakov Galka > > <ybungalobill(a)gmail.com> rote: > > > On Fri, Aug 12, 2011 at 12:00, Matus Chochlik > > > <chochlik(a)gmail.com> wrote: > > >> On Fri, Aug 12, 2011 at 9:57 AM, Daniel James > > >> <dnljms(a)gmail.com> wrote: > > >> > On 11 August 2011 12:57, Artyom Beilis > > >> > <artyomtnk(a)yahoo.com> wrote: > > > >> // by default expect UTF8 > > >> text(const std::string& str) > > >> { > > >> assert(is_utf8(str.begin(), str.end())); > > >> store(str); > > >> } > > > > > > What you are doing is, in fact, forcing the assumed > > > encoding of std::string to UTF-8. You just said you > > > think it's a bad idea. > > > > No, I'm proposing to implement a *new* class that > > will store the text in UTF8 encoding and if during > > the construction no encoding is specified, then it > > is assumed that the particular std::string is already > > in UTF8. > > > This is *very* different from imposing > > an encoding on std::string which is already > > used in many situations with other encodings. > > i.e. my approach does not break any existing code. > > Sorry, your arguments start to look non-constructive to me. > Correct me where I'm wrong in the following reasoning. > > (1) You object to UTF-8 strings in boost interface because > someone may pass something other than UTF-8 there and it's > going to be undetected at compile time: > > namespace boost { void func(const std::string& a); } // UTF-8 > boost::func(non_utf_string); //oops > > You're proposing a `text` class that is meant to somehow > overcome this problem. So you change the boost interface > to accept `text` but user code is left unchanged...: > > namespace boost { void func(const text& a); } > boost::func(non_utf_string); //oops, the std::string default > constructor is called. > > Yes, you can make this constructor explicit, so the above code > stops compiling and the user must write explicitly: > boost::func(text(non_utf_string)); > > But then there is nothing in your proposal that makes > std::string utf-8 encoded by 'default'. Default == implicit. As soon as the client did a cast, the client made the claim that non_utf_string met the requirements of the text class' constructor. The problem is that of the client misusing the class by an ill-advised cast. What's more, I think Soares indicated a debug-build validation that the argument indeed was UTF-8. I don't see a problem in that design, once the constructor is explicit. > > Besided it does not harm you in any way > > It does. I already use UTF-8 for all my strings, even on > windows, and I don't want the code-bloat of all these > conversions (even if they're no-ops). What code bloat do you get from NOPs? Sure, there is more compilation time for the compiler to parse the text code and then for the optimizer to streamline it into a NOP, but even that is very likely negligible. _____ Rob Stewart robert.stewart(a)sig.com Software Engineer using std::disclaimer; Dev Tools & Components Susquehanna International Group, LLP http://www.sig.com ________________________________ IMPORTANT: The information contained in this email and/or its attachments is confidential. If you are not the intended recipient, please notify the sender immediately by reply and immediately delete this message and all its attachments. Any review, use, reproduction, disclosure or dissemination of this message or any attachment by an unintended recipient is strictly prohibited. Neither this message nor any attachment is intended as or should be construed as an offer, solicitation or recommendation to buy or sell any security or other financial instrument. Neither the sender, his or her employer nor any of their respective affiliates makes any warranties as to the completeness or accuracy of any of the information contained herein or that this message or any of its attachments is free of viruses.

3 2

[Review] Lockfree review: today (July 28th) is the last day
by Hartmut Kaiser 16 Aug '11

16 Aug '11

All, Today is the last day of the review of Tim Blechmann's Lockfree library. If you're interested in this library, please consider contributing a review! If you need more time, please contact me privately. Please see the original (slightly corrected) announcement below: ----------------------------------------------------- About the library: Boost.Lockfree provides implementations of lock-free data structures. Lock-free data structures can be accessed by multiple threads without the necessity of blocking synchronization primitives such as guards. Lock-free data structures can be used in real-time systems, where blocking algorithms may lead to high worst-case execution times, to avoid priority inversion, or to increase the scalability for multi-processor machines. The following data structures are provided: - boost::lockfree::fifo, a lock-free fifo queue - boost::lockfree::stack, a lock-free stack - boost::lockfree::ringbuffer, a wait-free single-producer/single-consumer ringbuffer. The library is accessible from here: http://tim.klingt.org/boost_lockfree.tar.gz. Boost.Lockfree depends on C++0x atomics. They are not well supported with current compilers yet. For this reason Boost.Lockfree depends on the *unreviewed* Boost.Atomic library, that emulates C++0x atomics for C++98. This review is about Boost.Lockfree and not about Boost.Atomic, although it is included in the tarball and the git repository. If Boost.Lockfree will be accepted, it won't be merged into trunk before Boost.Atomic is accepted. --------------------------------------------------- Please always state in your review, whether you think the library should be accepted as a Boost library! Additionally please consider giving feedback on the following general topics: - What is your evaluation of the design? - What is your evaluation of the implementation? - What is your evaluation of the documentation? - What is your evaluation of the potential usefulness of the library? - Did you try to use the library? With what compiler? Did you have any problems? - How much effort did you put into your evaluation? A glance? A quick reading? In-depth study? - Are you knowledgeable about the problem domain? Regards Hartmut Review Manager

6 7

Re: [boost] [gsoc] Request Feedback for Boost.Ustr Unicode String
by Joe Mucchiello 16 Aug '11

16 Aug '11

>> text t6(pq_some_func(), textenc::libpq()); >> > You don't need it. You're proposing a design that tries to solve a > non-existing problem. There is no such diversity of encodings in the > interfaces. I don't know what is libpq, but it either uses UTF-8 in which > case you write: > > string t6 = pq_some_func(); > I think the point here that you don't need to know the encoding of libpq. If the policy is that you use this text class and that to use it you convert it using the standard text constructor that takes the listed tag. For libraries that use UTF-8 the conversion is a no-op. Adapting a new library to the "boost way" just involves adding a new tag to the textenc namespace and, if necessary, writing a new pair conversion routines.

2 1

[1.44][serialization] Link error with polymorphic archives and BOOST_CLASS_EXPORT
by Ralph Tandetzky 15 Aug '11

15 Aug '11

Hi, I discovered a problem, that has been previously discussed in a post from 2011-01-21 which has the same title. No concluding answer was given there, so I post the problem again. Essentially, the following code compiles but doesn't link: -------------------------- #include <sstream> #include <boost/serialization/export.hpp> #include <boost/archive/polymorphic_binary_oarchive.hpp> class A { public: template<class Archive> void serialize(Archive & ar, const unsigned version) { } }; BOOST_CLASS_EXPORT(A) int main() { A a; std::ostringstream os; boost::archive::polymorphic_binary_oarchive oa(os); oa & a; } -------------------------- Removing the line with "BOOST_CLASS_EXPORT(A)" or turning the "polymorphic_binary_oarchive" into a "binary_oarchive" removes the linker error. With Visual Studio 10 the following error message occurs: main.obj : error LNK2001: unresolved external symbol "public: static void __cdecl boost::archive::detail::archive_serializer_map<class boost::archive::detail::polymorphic_oarchive_route<class boost::archive::binary_oarchive_impl<class boost::archive::binary_oarchive,char,struct std::char_traits<char> > > >::erase(class boost::archive::detail::basic_serializer const *)" (?erase@?$archive_serializer_map@V?$polymorphic_oarchive_route@V?$binary_oarchive_impl@Vbinary_oarchive@archive@boost@@DU?$char_traits@D@std@@@archive@boost@@@detail@archive@boost@@@detail@archive@boost@@SAXPBVbasic_serializer@234@@Z) 1>main.obj : error LNK2001: unresolved external symbol "public: static bool __cdecl boost::archive::detail::archive_serializer_map<class boost::archive::detail::polymorphic_oarchive_route<class boost::archive::binary_oarchive_impl<class boost::archive::binary_oarchive,char,struct std::char_traits<char> > > >::insert(class boost::archive::detail::basic_serializer const *)" (?insert@?$archive_serializer_map@V?$polymorphic_oarchive_route@V?$binary_oarchive_impl@Vbinary_oarchive@archive@boost@@DU?$char_traits@D@std@@@archive@boost@@@detail@archive@boost@@@detail@archive@boost@@SA_NPBVbasic_serializer@234@@Z) Is there something wrong with the serialization library? Regards, Ralph Tandetzky.

2 2

Review Request: Singularity
by Ben Robinson 15 Aug '11

15 Aug '11

Hello, I would like to thank the Boost community for their invaluable feedback regarding the features and implementation details of Singularity. Singularity has been greatly refined and I am now requesting a formal review. I have compiled and run Singularity on 4 different compilers: GCC 4.5, MSVC++ 2010, the CL2000 TI compiler targeting the 2803x processor, and the Green Hills compiler targeting the Cortex-A8 ARM processor. The documentation, implementation and Boost unittests are available on GitHub at https://github.com/icaretaker/Singularity. Please note, that I have also implemented Singularity in C++11 using perfect function forwarding in the /cpp11 subdirectory, but that is not part of the submission, unless Boost is accepting C++11 libraries at this time. I will now include an excerpt of the documentation file "singularity.htm" which is part of the GitHub download: Introduction<file:///C:/home/ben/workspace_boost/boost/source/common/libs/singularity/singularity.htm#singularity.introduction> The Singularity Design Pattern allows you to restrict any class to a single instance. Singularity gives you direct control over the lifetime of the object, and does not require you to grant global access to the object, nor limit you to a single constructor for that object. Motivation<file:///C:/home/ben/workspace_boost/boost/source/common/libs/singularity/singularity.htm#singularity.motivation> The ability to restrict a class to a single instance is an important technique. While the commonly used Singleton Design Pattern achieves the desired goal, it introduces three undesirable limitations, namely: 1. Lifetime: Singleton introduces lifetime management complexities. The undefined destruction order of multiple singletons is just one example. 2. Scope: Singletons are always globally accessible. Accessibility should be orthogonal to restrictions on the number of instances. 3. Initialization: Singletons typically restricts the class to the default constructor. This makes Singleton difficult for classes which require non-default constructors. Like Singleton, Singularity restricts a class to a single instance. However Singularity does not suffer from lifetime, scoping and initialization problems. The following are the advantages of Singularity over Singleton: 1. The lifetime of the single object is bounded by calls to create() and destroy(). This lifetime is managed similiarly to objects bounded by calls to new() and delete(). 2. Singularity does not force global access to the instance. If global access is required, then a globally accessible get_global() function can be enabled upon creation of the instance. 3. Singularities of objects can be created using any available constructor for that object. Thank you, Ben Robinson, Ph.D.

2 1

Re: [boost] [containers review] A reminder that the containers review ends tomorrow
by John Maddock 14 Aug '11

14 Aug '11

> Just a quick reminder that the containers lib review ends tomorrow - there > have been lots of good comments, but not so many reviews - so now's your > chance ;-) If there are any reviews pending that are likely to be late > please let me know so we can extend the review period. This review was sent to me privately, posted here for comment: ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Review of Boost.Contianer by Zoltán Tóth I am not an expert of C++ containers topic, but use them daily in my algorithm programming job. C++ 1998 STL containers have serious deficiencies, I would say especially node-based STL containers are not usable at all for performance-critical algorithms due to their memory allocator treatment/requirements. I have written own implementations for STL vector, set, list, ., because I was not satisfied with STL containers. Therefore a replacement of those in Boost could be a terribly useful library. I did not try to use the library. I just quickly read the documentation, and found that it is very poor. Here are the deficiencies I have found in the documentation: 1. One of the most important reason to replace the STL containers is the treatment of custom memory allocators. However the documentation tells only a single sentence about it: "Containers support stateful allocators and are compatible with Boost.Interprocess (they can be safely placed in shared memory). " 1. It does not specify how the containers are swapped: are the allocators swapped with the container? 2. Most STL implementations have been supporting stateful allocators for years now. So it is not big news. However I am not satisfied with the way they might do it. For example Visual Studio's STL implementation require the allocator type to have a template copy constructor. Such allocator types are difficult to be implemented in efficient, threads-friendly way. (This is the reason I have implemented my own set implementation instead of STL::set) The documentation does not tell whether this library have a similar requirement. If no, that would be big news. 2. The documentation says: "All containers offered by Boost.Container can be used in recursive data structures, something that is not guaranteed by the standard". To understand the value of this feature better I as a user would like to know more about this topic. Please insert links or own text here that explain why does the standard not guarantee this. Is there any danger or difficulty in it? If yes: how does this library overcome them. IMHO Boost.Containers should not (yet) be accepted (because of the lack of a detailed documentation).

3 2