- Boost - lists.boost.org

[Pointer Container] Modification of pointer containers to allow const elements
by Gerardo Hernández 16 Oct '10

16 Oct '10

The following code snippet: boost::ptr_vector<const int> v; v.push_back(new int); produces the following error message (Visual C++ 9, boost 1.44): boost\ptr_container\ptr_sequence_adapter.hpp(249) : error C2664: 'std::vector<_Ty,_Ax>::push_back' : cannot convert parameter 1 from 'const int *' to 'void *const &' The problem is that the underlying type of boost::ptr_vector<T> is always vector<void*>, no matter T is const. This prevents push_back() method from maintaining const-correctness. The rest of the pointer containers contain an equivalent problem and this has been a TODO for some time. According to Thorsten Ottosen (library author) ( https://svn.boost.org/trac/boost/ticket/3832 ): "The fix is basically just some meta-functions taking into account that T might be const, and if so, instantiate container<const void*> instead of container<void*>" To the vector problem, this means that the underlying type should be: vector<typename boost::mpl::if_<boost::is_const<T>, const void*, void*> > I have sucessfully applied this approach to the pointer containers that mimic STL counterparts (see attachment) and I guess it should work for the others. I need feedback on whether this is a completely correct approach and if so I would like to contribute a modification. Gerardo.

5 10

[optional] memory use for optional refs and ptrs
by Rutger ter Borg 15 Oct '10

15 Oct '10

Hello, I'm looking into boost::optional<> as a replacement for some of my code which has to deal with optional values. However, it seems that cases which are usually space-efficient optionals (e.g., ptrs in the form of a null-ptr) do not have template specializations. In other words, boost optional templates store a bool and the memory footprint of its template parameter, regardless of type. I.e., optional references and pointers take their space plus the space of an extra bool. Is there a reason for this? Thanks, Rutger

15 42

New Boostcon sessions uploaded
by Marshall Clow 14 Oct '10

14 Oct '10

Michael Caisse: Using Spirit V2: Qi and Karma http://blip.tv/dashboard/episode/4162161 Stephan T. Lavavej: Data Structure Visualizers in Visual Studio 2010 http://blip.tv/dashboard/episode/4162044 Matt Calabrese, Zachary Laine: Instantiations Must Go! http://blip.tv/dashboard/episode/4161957 Jeremy Siek: Generic Programming And the Boost Graph Library http://blip.tv/dashboard/episode/4161923 More to come (I'm shooting for one session every other day)..... -- Marshall

13 24

C++0x trailing return type
by Matt Calabrese 14 Oct '10

14 Oct '10

I'd like to introduce a macro to Boost.Config called BOOST_NO_TRAILING_RETURN_TYPE for checking if a compiler supports 0x trailing return types I.E. auto foo() -> void; Is there general agreement that this is an appropriate name for the macro? Now for a small rant -- in a recent thread, I talked about introducing a simple BOOST_AUTO_FUNCTION macro which I'll request review for shortly, as a way to simulate automatic return type deduction when writing functions and function templates. In experimenting with the macro, I have hit what I believe is either a bug in GCC or what I would consider a huge failing of C++0x trailing return types (someone please aid me in figuring this out). One of the main reasons why trailing return types are helpful is that the arguments to the function or function template you are writing are able to be refered to when forming the return type, however, when dealing with non-static member functions, it seems to me that you are not able to refer to "this" or non-static members. This greatly reduces the usefulness of trailing return types, as all of the reasons why you would want to refer to the parameters apply with the same rationale to why you would want to refer to members and "this". I've skimmed through the standard and see no explicit mention of or examples of using trailing return types in this manner. Perhaps someone here can help parse the standard-ese to clarify? I'd hope that you could refer to non-static members, but I see no evidence of that. One example of why this is frustrating in practice can be seen in the following hypothetical code for a Boost.Variant-style template with an "emplace" member-function that is intended to construct an object in-place similar to the emplace family of member functions of C++0x containers: http://codepaste.net/u5nfis Here, the trailing return type is used almost exclusively for extended SFINAE, though you often wish to refer to members in other cases as well where SFINAE isn't of any concern. The overall goal with the implementation of emplace being as such is to attempt to force substitution to fail if any of the following cases were true: if "Type" does not have a constructor taking the forwarded arguments if "Type" is not one of the types that is able to be stored in the template and possibly even something else I've missed (...which is a good thing...) Essentially we want substitution to fail if the instantiation of the body would fail, giving a very basic equivalent to low-level, syntax-only, automatic concept-checking. The benefit of this speaks for itself. Here, at least in my opinion, such code is very concise, very powerful, and surprisingly readable. Without such functionality of trailing return types we can only do marginally better than we've been doing for the past 10 years. So if someone could help me determine whether or not what I'm trying to do is standard I'd be grateful, and if such functionality is not standard, is it too late for it to be added? It seems to me that the benefits with respect to library development here are too great for a community like Boost to ignore, though I myself am not familiar enough with the standardization process to make an impact. Thanks. It appears this rant has overshadowed the original question, though please don't forget to respond. -- -Matt Calabrese

4 3

Schedule on www.boost.org
by Rene Eng 14 Oct '10

14 Oct '10

Hi all Following the release schedule on www.boost.org, preparations for the release 1.45 are already underway. But I have not read anything here on the mailing list yet. Could somebody please either confirm the intention to keep those release dates, or otherwise adjust the dates in the release schedule? Thank you very much in advance René Eng -- “Dubito ergo cogito; cogito ergo sum. (I doubt, therefore I think; I think therefore I am)” René Descartes

2 1

[geometry]
by Paul Blampspied 13 Oct '10

13 Oct '10

I have been looking at the advance version of [boost][geometry]. I think it is very useful and very well worked out. I have a question. Does [geometry] support the idea of a frame of reference ? I believe not, but it may be that I have missed some way of achieving this. By reference frame I mean that some points are not directly comparable if they are in different frames of reference. This is distinct from different coordinate systems (I think). For example we could have two geographic coordinate systems, one referring to lat./long. on earth and another to Mars. the points on these two reference frames should not be comparable and should give a compile error. Can this be done in [geometry] ? More interestingly we could use two distinct reference frames for convenience, even though there is a known relation between them. It would be nice if point conversions between the two frames could be carried out (possibly implicitly). For example, I would like to do something like this: ShiftAndRotateTransform<EgocentricFrame, WorldFrame> EgoFrame_WorldFrame_Transform(10, 20, 90); //Shift by [10,20] and rotate 90deg. WorldFrame Test() { WorldFrame p1 = EgoFrame(0,0); EgocentricFrame p2 = WorldFrame(p1); return p2; //IMPORTANT - p2 is implicitly transformed to WorldFrame when returned from Test function. } I have managed to implement a very simple scheme which allows this to compile and work successfully, but I am not completely satisfied with my homebrew scheme. In particular, I am forced to declare the WorldFrame and EgoFrame classes and provide all the constructors for them. It is necessary to explicitly provide constructors for all the reference frames which can be converted - implying that this is known at the time the class is written. It is more flexible to use overloaded functions, because these can be added as required e.g. //The second argument is the output point which is modified. ChangeReferenceFrame(WorldFrame &p1, EgocentricFrame &p2); ChangeReferenceFrame(EgocentricFrame &p1, WorldFrame &p2); ChangeReferenceFrame(EgocentricFrame &p1, SomeNewFrameType &p2); However the syntactic convenience and possibility of implicit conversion is lost. I wonder if some sleight of template magic could allow the extensibility of the second approach with the usability of the first. The starting point would be to allow a class representing the transform between the two frames of reference to be declared. This should attempt to define as much of the machinery as possible. It seems to me that these facilities have no impact on the existing design of [geometry], but concern an extension to allow reference frames to be defined and related.

2 3

License question
by David Bellot 13 Oct '10

13 Oct '10

Hi guys, I'm working on a new library for some specific A.I and machine learning problems and I will release it as a Free Software of course. However, I wonder if you guys can enlighten me regarding license. This library will be template-based for some parts and compiled for other parts. I don't want to restrict users in what they're doing with the library, I mean they can use it for open-source or closed-source products. However, I want to decently protect my work and because it's template-based and can be used in commercial products, I don't want someone to do closed-source fork of it and all those kind of things... I selected to candidates: Boost and LGPL. So question: - do I have to use a Boost license or a LGPL license ? - and why not using GPL directly or is it too restrictive ? Thanks for your help, David (also boost::ublas maintainer when not doing statistics ;-) ) -- David Bellot, PhD david.bellot(a)gmail.com http://david.bellot.free.fr

5 5

Re: [boost] [function] function wrapping with no exception safety guarantee
by Dave Abrahams 12 Oct '10

12 Oct '10

On Tuesday, October 12, 2010, Emil Dotchevski <emil(a)revergestudios.com> wrote: > On Tue, Oct 12, 2010 at 4:04 PM, Daniel Walker > <daniel.j.walker(a)gmail.com> wrote: >> Formally, boost::function invocation has strong exception safety if >> invoking the target function has strong exception safety. > > This makes no sense at all. Invoking boost::function always has strong > exception safety guarantee. In no way it can make the state of the > boost::function object inconsistent, because it does not modify its > state. Sounds like you're talking about the basic guarantee here. > _____________________________________________ -- Dave Abrahams BoostPro Computing http://www.boostpro.com

2 1

Nightly tests failed with filesystem problem
by Belcourt, Kenneth 12 Oct '10

12 Oct '10

Hi, Tests failed last night for a problem with v3/src/operations.cpp. gcc.compile.c++ /scratch/boost/boost/bin.v2/libs/filesystem/build/ gcc-4.1.2/release/link-static/v3/src/operations.o "g++" -ftemplate-depth-128 -O3 -finline-functions -Wno-inline -Wall - DBOOST_ALL_NO_LIB=1 -DBOOST_SYSTEM_STATIC_LINK=1 -DNDEBUG -I"/scratch/ boost/ boost" -c -o "/scratch/boost/boost/bin.v2/libs/filesystem/build/ gcc-4.1.2/release/link-static/v3/src/operations.o" "/scratch/boost/ boost/libs/filesystem/v3/src/operations.cpp" /scratch/boost/boost/libs/filesystem/v3/src/operations.cpp: In function ‘boost::filesystem3::file_type<unnamed>::query_file_type(const boost::filesystem3::path&, boost::system::error_code*)’: /scratch/boost/boost/libs/filesystem/v3/src/operations.cpp:467: error: no matching function for call to ‘symlink_status(const boost::filesystem3::path&, boost::system::error_code*&)’ /scratch/boost/boost/boost/filesystem/v3/operations.hpp:209: note: candidates are: boost::filesystem3::file_status boost::filesystem3::symlink_status(const boost::filesystem3::path&) /scratch/boost/boost/boost/filesystem/v3/operations.hpp:211: note: boost::filesystem3::file_status boost::filesystem3::symlink_status(const boost::filesystem3::path&, boost::system::error_code&) Can someone please take a look? Thanks. -- Noel

1 0

[proto] Writing a transform to get at an inner constant of a transform result type
by Sebastian Redl 12 Oct '10

12 Oct '10

Hi, The subject is probably very confusing. I'm back to playing with a proto-based library for vector types. I have a basic underlying vector template, simd_impl: template <typename T> struct simd_impl { static const size_t size = VECTOR_BYTES / sizeof(T); // data }; And I have a grammar, Simd struct Simd : proto::or_< SimdLiteral, SimdUnary, SimdVectorBinary, SimdMixedBinary > {}; where SimdLiteral is an enumeration of proto::terminal<simd_impl<T>> where T are various underlying types, SimdUnary are unary operations, SimdVectorBinary are combinations of two vectors, and SimdMixedBinary are combinations of vectors with scalars. SimdVectorBinary is currently defined approximately like this: struct SimdVectorBinary : proto::or_< proto::when<proto::plus<Simd, Simd>, exec::simd_plus(Simd(_left), Simd(_right))>, // more operators here > {}; Now I want to validate, in the grammar, that you only add two vectors of the same arity together. That is, I'm fine with adding simd_impl<long> and simd_impl<int> together if they have the same size, because both have the same number of elements, but adding simd_impl<short> and simd_impl<int> together doesn't work, as one has twice the number of elements as the other. But I can't figure out how to write a grammar that validates this. I've started something like this: struct VSizeMatches : proto::if_<mpl::equal_to<Arity(proto::_left), Arity(proto::right)>()> {}; but I think that's wrong, and I can't figure out how to write Arity anyway. Basically, I have to find the simd_impl<T> type that the result of my Simd transform has and then access the size member. But I'm kinda afraid that this will get me into a world of trouble with prematurely instantiated templates. Any advice? Sebastian

2 2