- Boost - lists.boost.org

Development Practices (Proposal Progress)
by Dean Michael Berris 13 Jan '11

13 Jan '11

Hi Everyone, I was looking around at the Trac wiki and saw that there's a page called "ImprovingPractices". It's https://svn.boost.org/trac/boost/wiki/ImprovingPractices if you want to look. The Objectives stated on the page are definitely the same ones I am looking to address with a proposal I was thinking of writing from scratch. A quick read through definitely seems to me that there is significant overlap between what I had in mind and what's already in this document. One thing that doesn't seem to be in this document, is how to get new libraries into a Boost distribution. I'm not sure if this part should be in the same document either, but I really do think that somehow the continuity between the development of a library for inclusion into Boost and the release procedure should be in-tune. The document also assumes that the development of a library happens in the same repository -- mainly because it assumes that subversion is going to be used exclusively. That's understandable, but in the case of a proposal to support Git-based libraries as well I wonder whether it's alright if I edit this document for the proposed enhancements. So my question would be: - What would be the best way for me to solicit feedback on a proposal that tweaks the current process? Is editing this wiki page the way or should I create a new one? - Because there a number of parts of the proposal I'm going to write that deal with things on the front-end of the process (the interest-gathering, development (collaborative or otherwise), and review/inclusion part) as well as the back-end of the process (distribution maintenance, bug fixing / patching, and release management / packaging) is it better if these areas are described in different Wiki pages or should one page with different sections suffice? - Is the Wiki the best place to put this? Would others be more comfortable in a different means of looking at and commenting on a complete proposal? Thanks in advance and I definitely look forward to feedback and guidance. -- Dean Michael Berris about.me/deanberris

3 3

[type_traits] common_type fails when typeof is not used
by vicente.botet 13 Jan '11

13 Jan '11

Hi, The current common_type implementation doesn't works when BOOST_COMMON_TYPE_DONT_USE_TYPEOF is defined. This is needed on platforms that don't support Boost.Typeof correctly. It seems that the the implementation proposed by Jeffrey Hellrung has not been applied completly. I have attached a complementaty test on builting types that proves the current code does't works and also the implementation proposed by Jeffrey Hellrung to solve these issues some time ago. John, let me know if this works for you and if it can be included on trunk (I could do it myself if you prefer). Best, _____________________ Vicente Juan Botet Escribá http://viboes.blogspot.com/

3 5

Boost.Filesystem v3 as default in Boost 1.46.0?
by Jeremiah Willcock 12 Jan '11

12 Jan '11

Will the default version of Boost.Filesystem be v3 in the Boost 1.46.0 release? The current release branch still has v2 as the default (at least in <boost/filesystem.hpp>). Also, if I want to write code that works for both v2 and v3, should I test the BOOST_FILESYSTEM_VERSION macro directly? -- Jeremiah Willcock

4 3

[spirit] semantic action for mismatches?
by caustik 12 Jan '11

12 Jan '11

I've come to notice that there seems to be a missing bit of symmetry in spirit with regards to semantic actions. If a rule matches, and thus executes it's semantic action(s), but a rule which includes that rule mismatches, there seems to be no way to "unwind" the code executed down the chain. For example, if one of your semantic actions allocates memory or increments a reference count, how do you free / release that reference in the mismatch scenario? I've thought about using something like a shared_ptr, but it seems like that gets pretty sloppy and unnatural. Is there something you can think of that would work? caustik

5 25

[move] abiguious ctor (msvc-10.0)
by Oliver Kowalke 11 Jan '11

11 Jan '11

I get error C2668 with msvc-10.0 - (gcc.4.x works). Any ideas? 1>test.cpp(44): error C2668: 'X::X': Mehrdeutiger Aufruf einer überladenen Funktion 1> test.cpp(19): kann 'X::X<boost::_bi::bind_t<R,F,L>>(Fn &&,size_t)' sein 1> with 1> [ 1> R=void, 1> F=void (__cdecl *)(int), 1> L=boost::_bi::list1<boost::_bi::value<int>>, 1> Fn=boost::_bi::bind_t<void,void (__cdecl *)(int),boost::_bi::list1<boost::_bi::value<int>>> 1> ] 1> test.cpp(16): oder "X::X<boost::_bi::bind_t<R,F,L>>(Fn,size_t)" 1> with 1> [ 1> R=void, 1> F=void (__cdecl *)(int), 1> L=boost::_bi::list1<boost::_bi::value<int>>, 1> Fn=boost::_bi::bind_t<void,void (__cdecl *)(int),boost::_bi::list1<boost::_bi::value<int>>> 1> ] 1> bei Anpassung der Argumentliste '(boost::_bi::bind_t<R,F,L>, int)' 1> with 1> [ 1> R=void, 1> F=void (__cdecl *)(int), 1> L=boost::_bi::list1<boost::_bi::value<int>> 1> ] test app: #include <cstdlib> #include <iostream> #include <boost/bind.hpp> #include <boost/move/move.hpp> class X { private: BOOST_COPYABLE_AND_MOVABLE( X); public: X() {} template< typename Fn > X( Fn fn, std::size_t i) {} template< typename Fn > X( BOOST_RV_REF( Fn) fn, std::size_t i) {} X( X const& other) {} X & operator=( BOOST_COPY_ASSIGN_REF( X) other) { X tmp( other); return * this; } X( BOOST_RV_REF( X) other) {} X & operator=( BOOST_RV_REF( X) other) { X tmp( boost::move( other) ); return * this; } }; void f( int) {} int main() { try { X x( boost::bind( f, 1), 1); return EXIT_SUCCESS; } catch ( std::exception const& e) { std::cerr << "exception: " << e.what() << std::endl; } catch (...) { std::cerr << "unhandled exception" << std::endl; } return EXIT_FAILURE; } -- Neu: GMX De-Mail - Einfach wie E-Mail, sicher wie ein Brief! Jetzt De-Mail-Adresse reservieren: http://portal.gmx.net/de/go/demail

2 3

[local] local functions ready for review
by Lorenzo Caminiti 11 Jan '11

11 Jan '11

Hello all, A few months ago, I probed for interest in a library for local functions with Boost.ScopeExit's variable binding. Based on that discussion, I have now implemented the Boost.Local library. I have uploaded the source files boost-local_0_1_0-818.zip in the Boost Vault under Function Objects: http://www.boostpro.com/vault/index.php?&direction=0&order=&directory=Funct… The documentation on the web: http://contractpp.sourceforge.net/boost-local_0_1_0-818/libs/local/doc/html… Any comment? As far as I can tell, Boost.Local is ready for a formal review so I am looking for a review manager. Any volunteer? Thanks, Lorenzo ________________________________________________ P.S. A preview from Boost.Local's documentation: The Boost Local library implements local functions, local blocks, and local exits for the C++ programming language. INTRODUCTION Local functions are a form of information hiding and are useful for dividing procedural tasks into subtasks which are only meaningful locally, avoiding cluttering other parts of the program with functions, variables, etc unrelated to those parts. Local functions therefore complement other structuring possibilities such as namespaces and classes. Local functions are a feature of many programming languages, notably Pascal and Ada, yet lacking from C++ (see also [N2511]). This library supports the following features for local functions (see the Alternatives section for a comparison between this library and features offered by C++ local class members, C++0x lambda functions, Boost.Lambda, Boost.Phoenix, and Boost.ScopeExit): * Local functions can access, or better bind, any of the variables from the enclosing scope. Furthermore, local functions defined within a member function can bind the enclosing object this. * The local function body is programmed using the usual C++ syntax. * Local functions can be passed as template parameters (so they can be conveniently passed to STL algorithms, etc). * However, local functions must be defined within a declarative context (e.g., at a point in the code where local variables can be declared) thus they cannot be defined within an expression. In addition to local functions, this library also supports the following features: * Local blocks which define blocks of code that bind variables from the enclosing scope. Local blocks allow programmers to bind variables as constants (constant binding) so to prevent local chunks of code from modifying selected variables. * Local exits which define blocks of code that are executed when the enclosing scope is exited (again with support for constant binding and binding of the object this). AN EXAMPLE The following example illustrates a simple use of this library and it starts introducing the library API (see the Tutorial section for more details on how to use this library): * A local function is passed to the STL std::for_each() algorithm to add together the values of an array. Variables in scope are bound to the local function by both constant value and non-constant reference. * A local exit is used to automatically release the array's memory at scope exit. * A local block is used to assert the correct final value of the summation in a constant-correct context (therefore preventing the assertion from mistakenly changing any of the variables in scope). #include <boost/local/function.hpp> #include <boost/local/block.hpp> #include <boost/local/exit.hpp> #include <algorithm> #include <iostream> #include <cassert> int main() { double sum = 0.0; int factor = 10; BOOST_LOCAL_FUNCTION( (void) (add)( (double)(num) (const bind)((factor)) (bind)((&sum)) ) ) { sum += factor * num; std::clog << "Summed: " << sum << std::endl; } BOOST_LOCAL_FUNCTION_END(add) add(100.0); size_t size = 2; double* nums = new double[size]; BOOST_LOCAL_EXIT( (const bind)((&size)) (bind)((nums)) ) { if (size && nums) delete[] nums; std::clog << "Freed array: " << nums << std::endl; } BOOST_LOCAL_EXIT_END nums[0] = 90.5; nums[1] = 7.0; std::for_each(nums, nums + size, add); BOOST_LOCAL_BLOCK( (const bind)((&sum)) ) { // So far: sum = 10 * 100.0 + 10 * 90.5 + 10 * 7.0 = 1975.0 assert(sum == 1975.0); std::clog << "Asserted summation: " << sum << std::endl; } BOOST_LOCAL_BLOCK_END return 0; }

2 5

[geometry] Excessive inspection report errors
by Beman Dawes 10 Jan '11

10 Jan '11

See http://boost.cowic.de/rc/inspect-trunk.html#geometry A bunch of these problems are related to documentation - Daniel James and some of the other Boost doc folks have dealt with similar problems in other libraries, so can probably help. Thanks, --Beman

2 3

[QuickBook] missing prev/next
by Lorenzo Caminiti 10 Jan '11

10 Jan '11

Hello all, I have generate the Boost.Units documentatiom using Boost.QuickBook from the latest Boost release 1.45.0 but the HTML pages are missing the prev and next page links. I only have the up and home links in the navbar. How can I get the prev and next links to show? Do I need to enable some XLS configuration in the Jamfile? Thank you very much. -- Sent from my mobile device Lorenzo

4 21

cygwin API: posix or windows
by vicente.botet 09 Jan '11

09 Jan '11

Hi, while trying to make Boost.System and Boost.Chrono configurable header only libs we need to include windows.h on some include files. To avoid the inclusion of this intrusive file, we decided sometime ago to include some files in detail/win that will present just the needed interfaces. In my humble opinion cygwin is a wrapper of posix intefaces under windows OS. So, boost libraries shouldn't use Windows interfaces when working under cygwin. What's the experience of others? Best, Vicente

10 10

[tasklets] new lib
by Oliver Kowalke 09 Jan '11

09 Jan '11

boost.tasklet is a split-up from old boost.fiber. The lib allow to execute micro-tasks (tasklets) in a thread and assigns each small task with a micro-thread/fiber - so tasklets are cooperativly scheduled. The API contains classes and functions to manage and synchronize tasklets (even if the tasklets are running on different threads). boost.tasklet is an example how boost.fiber could be used for cooperative scheduling ansd will be used by the threadpool from boost.task. Oliver

2 3