- Boost-users - lists.boost.org

AIX 5.3 xlC error on ptr_list.hpp
by Gary Fu 21 Aug '08

21 Aug '08

Hi, The simple test program a.cpp below has no problem to compile on linux g++, but failed on AIX xlC compiler. Does any one know if the problem is related to the xlC compiler or the ptr_list.hpp file ? Thanks, Gary 4:43pm 19 Ggfu@sds:~/tmp> xlC_r -I/home_dir/Ggfu/BOOST/boost_1_36_0 -c a.cpp "/home_dir/Ggfu/BOOST/boost_1_36_0/boost/ptr_container/ptr_list.hpp", line 44.9: 1540-0400 (S) "boost::ptr_list::release" has a conflicting declaration. "/home_dir/Ggfu/BOOST/boost_1_36_0/boost/ptr_container/ptr_list.hpp", line 44.9: 1540-0425 (I) "release" is defined on line 44 of "/home_dir/Ggfu/BOOST/boost_1_36_0/boost/ptr_container/ptr_list.hpp". ----------------- a.cpp #include <boost/ptr_container/ptr_list.hpp> boost::ptr_list< std::string > y; int main() { return 0; }

3 2

How to find a sorting permutation
by Zeljko Vrba 21 Aug '08

21 Aug '08

I have a vector of element V that needs to be sorted. I want to also produce a permutation vector P which reflects the element's position in the original vector. P is initialized with identity permutation (P[i] == i). 1st possibility: code my own sorting algorithm, and swap elements of P along with swapping elements of V. This I want to avoid, if at all possible. 2nd possibility: copy elements of V into new vector V' holding pair<T, size_t> and sort that. (pair holds the original element as well as its starting position in the vector, i.e. .second is again initialized to identity permutation.) Drawback: extra space and time spent on copying to V'. 3rd possibility: sort elements of P with less_than doing lookups into V to do its comparison. Drawback: while P holds the correct result, V is left unsorted; I have to do another pass through V and swap elements according to the permutation recorded in P, which is not trivial to do in-place. 4th possibility: I'm not sure whether it'd work: have a separate compilation unit that will provide function sort_vector_of_T, which will take references to V, T and also provide a specialization of std::swap for T which will then also swap elements of P). (Separate compilation unit is needed because I don't want to *globally* redefine std::swap for T) Is there some non-obvious, efficient and elegant way of achieving what I want?

3 3

Implementation question about boost::circular_buffer and allocator
by Peter Barker 21 Aug '08

21 Aug '08

Hello, I've been going through the Boost libraries and encountered boost::circular_buffer. My question is not with the operation of Boost.Circular Buffer as-such, but about how the instantiation of it works without specifying the allocator. The introductory example in the documentation(http://www.boost.org/doc/libs/1_35_0/libs/circular_buffer/doc… contains the following line: // Create a circular buffer with a capacity for 3 integers. boost::circular_buffer<int> cb(3); But looking at the header file base.hpp in the circular_buffer directory, we have the following: template <class T, class Alloc> class circular_buffer { ...... }; The Alloc template parameter is not a default one, so I can't understand how we can instantiate cb in the example? Apologies if this is not strictly boost-user related. Regards, Jim

2 2

multi_array, resize and default constructable
by gast128 21 Aug '08

21 Aug '08

Dear all, from the documentation I read that if a multi_array is reshaped new elements are default constructed: "Resizing an Array The boost::multi_array class provides an element-preserving resize operation. ...Any new elements in the array are default constructed..." It is thus not possible providing a default fill element?

2 2

weak_ptr for intrusive_ptr
by Alan M. Carroll 21 Aug '08

21 Aug '08

I greatly prefer intrusive_ptr to shared_ptr, but one drawback of that is there is no equivalent of weak_ptr. I have started work on a class to do that and my biggest question, honestly, was what to name it. The basic logic turned out to be fairly simple. The target class declares a member that is an instance of the weak pointer. Other classes that want a weak pointer to the target instance also declare a member weak pointer, which must be initialized with a copy of the target instance member. The member provides a method to generate an intrusive_ptr to the target, which is either valid or nil depending on whether the target has been destructed. When the target and all weak pointers are destructed, everything gets cleaned up. The weak pointers don't affect the target reference count. No changes to Boost.intrusive_ptr are required. The one improvement I see would be to merge it into the reference counter utility class discussed earlier (optionally, of course - perhaps via a subclass of the reference counter). Yeah, I think I'll do that. My questions: 1) What would be a good name for such a class? I am using "tell_tale" for now, in analogy to tell tale lights on devices that go out when the device fails. Obviously "weak_ptr" is out. "weak_intrusive_ptr" seems a bit verbose, but may that's OK. 2) Is there any interest in Boostifying the class, or am I the only one who would use it? It's a matter of how much I indulge my idiosyncrasies.

4 8

Re: [Boost-users] Multi-index container (Modifying non-unique key in the container)
by JOAQUIN M. LOPEZ MUÑOZ 20 Aug '08

20 Aug '08

________________________________ De: boost-users-bounces(a)lists.boost.org [boost-users-bounces(a)lists.boost.org] En nombre de Ramesh [rramesh1(a)gmail.com] Enviado el: martes, 19 de agosto de 2008 20:16 Para: boost-users(a)lists.boost.org Asunto: Re: [Boost-users] Multi-index container (Modifying non-unique key in the container) On Wed, Aug 13, 2008 at 10:20 AM, JOAQUIN M. LOPEZ MUÑOZ <joaquin(a)tid.es<mailto:joaquin@tid.es>> wrote: ________________________________ De: boost-users-bounces(a)lists.boost.org<mailto:boost-users-bounces@lists.boost.org> [boost-users-bounces(a)lists.boost.org<mailto:boost-users-bounces@lists.boost.org>] En nombre de Ramesh [rramesh1(a)gmail.com<mailto:rramesh1@gmail.com>] Enviado el: martes, 12 de agosto de 2008 20:40 [...] Hmm... I'm not referring to your myclass wrapper, but rather to the fact that you're storing DataMaps objects into the container rather than A*s directly. Joaquín M López Muñoz Telefónica, Investigación y Desarrollo > Sorry if I got your question wrong, I am storing only pointers to objects > inside the map and each instance of myclass would hold one such > container to hold pointers to objects of class A along with keys. Yes, but DataMap seems to *replicate* the keys that are already present in A. Cannot you just have the following? typedef multi_index_container< A*, indexed_by< ordered_unique< tag <Key1>, BOOST_MULTI_INDEX_MEMBER(A,std::string,Key1)>, ordered_non_unique< tag<Key2>,BOOST_MULTI_INDEX_MEMBER(A,long,Key2)>, ordered_unique< tag<Key3>,BOOST_MULTI_INDEX_MEMBER(A,long,Key3)> > > tDMap; Joaquín M López Muñoz Telefónica, Investigación y Desarrollo

2 1

[Exception] 1.36.0: mutable Patch
by Peter Klotz 20 Aug '08

20 Aug '08

gcc 3.2 complains heavily about keyword mutable not being at the beginning of declarations. The attached patch fixes that. The C++ standard does not enforce mutable placement however since Boost is already full of compiler specific workarounds I would be happy if this patch could be applied. Regards, Peter. Peter Klotz Software Engineer Phone: +43 (0) 50 8648-4100 Fax: +43 (0) 50 8648-4111 E-Mail: peter.klotz(a)ith-icoserve.com ---------------------------------------------------------------- ITH icoserve technology for healthcare GmbH A-6020 Innsbruck, Innrain 98 www.ith-icoserve.com Rechtsform: Gesellschaft mit beschränkter Haftung Firmensitz: 6020 Innsbruck, Innrain 98 Firmenbuchnummer: FN 174117f Firmenbuchgericht: Innsbruck DVR: 0983039

2 3

[boost signal] problem with borland c++ builder 6
by Eric B 20 Aug '08

20 Aug '08

Hi I'm trying to use boost::signal to replace a library of my own It compiles well but at runtime It raises an exception on the following line boost::signal<> sig; the exception is raised in function_template.hpp template< typename FunctionObj, typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS > struct BOOST_FUNCTION_FUNCTION_OBJ_INVOKER { static R invoke(function_buffer& function_obj_ptr BOOST_FUNCTION_COMMA BOOST_FUNCTION_PARMS) { FunctionObj* f; if (function_allows_small_object_optimization<FunctionObj>::value) f = reinterpret_cast<FunctionObj*>(&function_obj_ptr.data); else f = reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr); return (*f)(BOOST_FUNCTION_ARGS); <<<<< exception raised here } }; Does the sig have to be initialized in a specific way ???

1 1

[GIL] Smart images
by Jan Funke 20 Aug '08

20 Aug '08

Hi, recently I wondered, whether there is any possibility to create a kind of "smart image", like the smart pointer of boost. What I'd like to have is an image, that frees it's allocated memory automatically on vanishing of the last view accessing it. Do you guys have any idea how to achieve this? Regards, Jan

3 2

boost:.tuple to tr1::tuple migration: default template args unspecified
by Markus Werle 20 Aug '08

20 Aug '08

> [ignore this gmane cheater line] Hi! Looks like migration from boost::tuple to std::tr1:.tuple is a lot more pain than I thought. I have some compile time magic class that makes use of the default template args of boost::tuple: template < typename T0 = boost::tuples::null_type, typename T1 = boost::tuples::null_type, typename T2 = boost::tuples::null_type, typename T3 = boost::tuples::null_type, typename T4 = boost::tuples::null_type, typename T5 = boost::tuples::null_type, typename T6 = boost::tuples::null_type, typename T7 = boost::tuples::null_type, typename T8 = boost::tuples::null_type, typename T9 = boost::tuples::null_type> struct string_to_tuple { // ... }; Now from the docs I see: namespace std { namespace tr1 { // [6.1.3] Class template tuple template <class T1 = unspecified , class T2 = unspecified , ..., class TM = unspecified > class tuple; which leaves me lost without typeof(std::tr1::ignore) at hand. Any idea how to get around this? Btw.: Why does the standard leave this type unspecified? To be more specific: rewrite this code based on std::tr1::tuple ;-) --- snip --- // Usage: // int main() // { // try // { // { // typedef boost::tuple<int, int> tuple_t; // // std::list<tuple_t> test = // string_to_tuple<int, int>::apply(" ( 1, 2 ) ( 3, 4)(5,6)"); // // std::copy(test.begin(), test.end(), // std::ostream_iterator<tuple_t> (std::cout, "\n")); // } // // { // typedef boost::tuple<unsigned int, int, double> tuple_t; // // std::list<tuple_t> test = // string_to_tuple<unsigned int, int, double>::apply // (" ( 1, -2 , 5.123) ( 3, 4,7.9)(5,6,8.6789)"); // // std::copy(test.begin(), test.end(), // std::ostream_iterator<tuple_t> (std::cout, "\n")); // } // // } // catch (std::exception const & e) // { // std::cerr << e.what() << std::endl; // } // } #ifndef BOOSTTUPLESFROMSTRING_H #define BOOSTTUPLESFROMSTRING_H // #define BOOST_SPIRIT_DEBUG_OUT std::cerr // #define BOOST_SPIRIT_DEBUG #include "Enforce.h" #ifndef PHOENIX_LIMIT #define PHOENIX_LIMIT 11 #else #if (PHOENIX_LIMIT < 11) #define ERROR_MESSAGE LOCATION ": " \ "PHOENIX_LIMIT must be a at least 11, but is " \ STRINGIZE(PHOENIX_LIMIT) #pragma message (ERROR_MESSAGE) #error Check the output for details #endif #endif #include <boost/config.hpp> // for BOOST_STATIC_CONSTANT #include <boost/spirit/core.hpp> #include <boost/spirit/attribute.hpp> #include <boost/spirit/core/non_terminal/rule.hpp> #include <boost/spirit/utility/lists.hpp> #include <boost/spirit/utility/loops.hpp> #include <boost/spirit/utility/confix.hpp> #include <boost/spirit/actor/push_back_actor.hpp> #include <boost/spirit/actor/assign_actor.hpp> #include <boost/spirit/phoenix/primitives.hpp> #include <boost/spirit/phoenix/functions.hpp> #include <boost/tuple/tuple.hpp> #include <boost/tuple/tuple_io.hpp> #include <list> #include <iterator> #include <algorithm> #include <string> namespace boost { namespace spirit { struct no_action { template< typename T, typename ValueT > void act(T& ref_, ValueT const& value_) const { // do nothing } template< typename T, typename IteratorT > void act( T& ref_, IteratorT const& first_, IteratorT const& last_ ) const { // do nothing } }; static inline boost::spirit::ref_value_actor<boost::tuples::null_type, no_action> assign_a(boost::tuples::null_type & nt) { boost::spirit::ref_value_actor<boost::tuples::null_type, no_action> na (nt); return na; } } // namespace boost } // namespace spirit namespace { struct append_tuple_to_container_impl { template <typename Container, typename String> struct result { typedef void type; }; template <typename Container, typename String> void operator()(Container& c, String const & s) const { typedef typename Container::value_type tuple_t; tuple_t t; std::istringstream ss(s); ss >> boost::tuples::set_open('(') >> boost::tuples::set_close(')') >> boost::tuples::set_delimiter(',') >> t; c.push_back(t); } }; phoenix::function<append_tuple_to_container_impl> const append_tuple_to_container = append_tuple_to_container_impl(); struct insert_as_tuple_impl { template <typename Container, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9> struct result { typedef void type; }; template <typename Container, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9> void operator()(Container & c, T0 const & t0, T1 const & t1, T2 const & t2, T3 const & t3, T4 const & t4, T5 const & t5, T6 const & t6, T7 const & t7, T8 const & t8, T9 const & t9) { c.push_back(boost::make_tuple(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9)); } }; phoenix::function<insert_as_tuple_impl> const insert_as_tuple = insert_as_tuple_impl(); template < typename T0 = boost::tuples::null_type, typename T1 = boost::tuples::null_type, typename T2 = boost::tuples::null_type, typename T3 = boost::tuples::null_type, typename T4 = boost::tuples::null_type, typename T5 = boost::tuples::null_type, typename T6 = boost::tuples::null_type, typename T7 = boost::tuples::null_type, typename T8 = boost::tuples::null_type, typename T9 = boost::tuples::null_type> struct string_to_tuple { //////////////////////////////////////////////////////////////////////// //// // type to boost::spirit parser mapping template <typename T, int Dummy = 0> struct parser; template <int Dummy> struct parser<boost::tuples::null_type, Dummy> { static inline boost::spirit::epsilon_parser p() { boost::spirit::epsilon_parser result; return result; }; static inline boost::spirit::epsilon_parser comma() { boost::spirit::epsilon_parser result; return result; } }; #define PARSER_TRAITS(TYPE, PARSER_T) \ template <int Dummy> struct parser<TYPE, Dummy> \ { \ static inline \ PARSER_T p() \ { \ PARSER_T result; \ return result; \ } \ \ static inline \ boost::spirit::strlit<char const *> comma() \ { \ boost::spirit::strlit<char const *> str_p(","); \ return str_p; \ } \ } PARSER_TRAITS(int, boost::spirit::int_parser<int>); PARSER_TRAITS(unsigned int, boost::spirit::uint_parser<unsigned>); typedef boost::spirit::real_parser <double, boost::spirit::ureal_parser_policies<double> > real_parser_t; PARSER_TRAITS(float, real_parser_t); PARSER_TRAITS(double, real_parser_t); template <int Dummy> struct parser<std::string, Dummy> { typedef boost::spirit::contiguous <boost::spirit::confix_parser <boost::spirit::strlit<const char*>, boost::spirit::kleene_star <boost::spirit::anychar_parser>, boost::spirit::strlit<const char*>, boost::spirit::unary_parser_category, boost::spirit::non_nested, boost::spirit::non_lexeme> > parser_t; static inline parser_t p() { using namespace boost::spirit; using namespace phoenix; parser_t result = lexeme_d[confix_p("\"" , (*anychar_p) , "\"")]; return result; } static inline boost::spirit::strlit<char const *> comma() { boost::spirit::strlit<char const *> str_p(","); return str_p; } }; // PARSER_TRAITS(std::string, quoted_string_grammar); //////////////////////////////////////////////////////////////////////// //// // typedefs and integral constants typedef typename boost::tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> tuple_t; BOOST_STATIC_CONSTANT(int, tuple_len = boost::tuples::length<tuple_t>::value); //////////////////////////////////////////////////////////////////////// //// // static inline std::list<tuple_t> apply(std::string const & s) { using namespace boost::spirit; using namespace phoenix; std::list<tuple_t> result; T0 t0; T1 t1; T2 t2; T3 t3; T4 t4; T5 t5; T6 t6; T7 t7; T8 t8; T9 t9; typedef rule<phrase_scanner_t> rule_t; rule_t rule_tuple_rep = (str_p("(") >> parser<T0>::p()[assign_a(t0)] >> parser<T1>::comma() >> parser<T1>::p()[assign_a(t1)] >> parser<T2>::comma() >> parser<T2>::p()[assign_a(t2)] >> parser<T3>::comma() >> parser<T3>::p()[assign_a(t3)] >> parser<T4>::comma() >> parser<T4>::p()[assign_a(t4)] >> parser<T5>::comma() >> parser<T5>::p()[assign_a(t5)] >> parser<T6>::comma() >> parser<T6>::p()[assign_a(t6)] >> parser<T7>::comma() >> parser<T7>::p()[assign_a(t7)] >> parser<T8>::comma() >> parser<T8>::p()[assign_a(t8)] >> parser<T9>::comma() >> parser<T9>::p()[assign_a(t9)] >> ")")[insert_as_tuple(var(result), var (t0), var(t1), var(t2), var (t3), var(t4), var(t5), var (t6), var(t7), var(t8), var (t9))] ; rule_t rule_tuple_list = *(rule_tuple_rep) >> end_p // for trailing whitespace ; BOOST_SPIRIT_DEBUG_RULE(rule_tuple_rep); BOOST_SPIRIT_DEBUG_RULE(rule_tuple_list); parse_info<> info; try { info = parse(s.c_str(), rule_tuple_list, space_p); } catch (std::exception const & e) { std::cerr << e.what() << std::endl; } ENFORCE(info.full) ("Failed to generate a list of tuples from ") ("string representation\n'") (s)("'\n"); return result; } }; } // namespace #endif // BOOSTTUPLESFROMSTRING_H

2 2