- Boost-users - lists.preview.boost.org

Boost.Serialization not building
by gast128 30 Nov '09

30 Nov '09

Dear all, we just upgrade to Boost 1.41 and get a compile error in Boost.Serialization: 1>c:\work sdk\boost_1_41_0\boost/archive/shared_ptr_helper.hpp(114) : error C2440: 'return' : cannot convert from 'const boost::serialization::extended_type_info_typeid<T>' to 'const boost::serialization::extended_type_info *' There was already a discussion about this on the newsgroup but no solution was posted: http://thread.gmane.org/gmane.comp.lib.boost.user/52384/focus=52390 The case is easy reproducable: struct Foo { //virtual ~Foo(){} }; struct Foo2 : public Foo { template <class Archive> void serialize(Archive& /*ar*/, const unsigned int /*version*/) { } }; struct Bla { template <class Archive> void serialize(Archive& ar, const unsigned int /*version*/) { ar & BOOST_SERIALIZATION_NVP(m_ptrFoo2); } boost::shared_ptr<Foo2> m_ptrFoo2; }; void F() { std::stringstream sstr; Bla bla; boost::archive::xml_iarchive ia(sstr); ia >> boost::serialization::make_nvp("bla", bla); } Can somebody help? Adding a virtual dtor does remove the problem (and is exactly the difference with 'test_shared_ptr.cpp') but this is unwanted. wkr

2 5

How well does Boost work on Windows CE 6.0 R3?
by Andreas Huber 29 Nov '09

29 Nov '09

Among others, we're considering to use the following Boost libraries on Windows CE 6.0 R3, with MSVC 9.0: date_time exception filesystem regex signals2 system thread For all of these libraries, the msvc-9.0~wm5~stlport5.2 toolset reports at least one test failure on the trunk. So: - Has anybody managed to use these libraries on CE 6.0? - With STLPort or the MS implementation? - If any, what tweaks were necessary? Also, has anybody used the following libs on CE: log (Semashev, proposed) futures (Williams, accepted but not yet added) ? Thanks, -- Andreas Huber When replying by private email, please remove the words spam and trap from the address shown in the header.

1 0

adding a compiler flag
by Igor R 29 Nov '09

29 Nov '09

Hello, Is it possible to add a c++ compiler flag to bjam line, when building a boost library, or what's the right way to do this? Thanks.

2 2

[1.41][regex] MSVC makefiles
by Chard 29 Nov '09

29 Nov '09

The MSVC makefiles for regex (libs/regex/build) create 1_40 filenames. I assume (at least) one of: - they missed the update. - they're obsolete; just use bjam. - I've missed something.

2 1

program_options
by Dejan 29 Nov '09

29 Nov '09

Hi all, I'm experimenting with program_options and trying to get something like "mandatory options". E.g. # my_prog -a someValue with "-a someValue" as mandatory options. Can I define "something" with program_options. Thanks in advantage Dejan

3 2

boost lambda for processing std::vector
by CR Koudella 29 Nov '09

29 Nov '09

Hi, I am trying to understand if boost.lambda is well suited for the quick processing of an std::vector<double>. I must apologize for my sketchy understanding of the library and this is the reason why I turn to you for your help. Imagine that we are given an std::vector<double>, say, x', of some size and that we need to extend x' somehow to x in order to use it as an argument for some function f. So, say x' = (3,3,3) and x can be obtained by some map as x = (3,1,3,1,3). Ideally, this problem would fit into function composition using bind or lambda::bind. Define g(x) = f[x(x')]. The composition operation is standard. What is not for me is how to write the function x(x') using boost.lambda. It is always possible to write a quick C++ functor that will encode in its state the map defining how to generate x from x'. This would typically proceed by constructing a return std::vector<double> to be populated according to the map. But, can this be done easily with boost.lambda also? I am not sure. I seem to be finding it difficult to formulate expressions that return types such as std::vectors, while operating on the vector elements. I can see that the library is well suited to write small functors on the fly that will operate on container items (as is documented), but when it comes to full containers, I am kind of stuck. Any attempt seems to be leading to complicated script and dead ends, which makes me think that I am better off relegating the case to a small C++ functor written elsewhere in the file. Not sure if you see where I am coming from, but in a functional programming language or a higher level scripting language such as python, this kind of operation is quite easy to do on the fly. What I am trying to figure out is how much of the 'in-place definition of code in c++' should reasonably be handled with boost.lambda. Again, I can clearly see the power of boost.lambda when applied to std::for_each or std::transform, etc..., but I am not sure how to leverage it beyond that and I haven't seen many examples out there trying to do that either. Insights and help greatly appreciated, Many thanks, ChrisK

2 1

Two questions on boost::function
by CR Koudella 29 Nov '09

29 Nov '09

Hi, thank you very much for your help. What you suggest works fine, thanks. I have 'studied' the boost lambda library a bit and get the feeling as it says in the intro to the doc that it is especially meant to write small lambda expressions for use with the STL. I am not actually that interested in this use and am having a bit of time trying to get it to do some other things. Imagine I want to do the following operation [h * (f - g)^2](x), where the x is 'const std::vector<double> &', all functions return double and h(x) = k1 and g(x) = k2, where k1, k2 = const. f is some non-trivial function. I can make this work according to the method you indicate. I am not entirely sure what the optimal is to build the lambda expressions for the constant functions h and g, see below. It seems that I need to drive this step through boost::function, otherwise the code won't compile. // some function f given... // constant h functor const double dh = 4.0; bll::constant_type<double>::type lh(bll::constant(dh)); boost::function<double (const std::vector<double> & vecArg)> bfoh; bfoh = lh; // constant g functor const double dg = 0.5; bll::constant_type<double>::type lg(bll::constant(dg)); boost::function<double (const std::vector<double> & vecArg)> bfog; bfog = lg; // construct h * (f - g)^2 // f - g boost::function<double (const std::vector<double> & vecArg)> bfoDF; bfoDF = bll::bind(f, bll::_1) - bll::bind(bfog, bll::_1); // (f - g)^2 boost::function<double (const std::vector<double> & vecArg)> bfoSF; bfoSF = bll::bind(bfoDF, bll::_1) * bll::bind(bfoDF, bll::_1); // h * (f -g)^2 boost::function<double (const std::vector<double> & vecArg)> bfoWRF; bfoWRF = bll::bind(bfoh, bll::_1) * bll::bind(bfoSF, bll::_1); Other than this, the repetitive use of bll::bind at every stage and generally speaking, the wordiness of the script makes me wonder whether this is the right thing to use or if I am using it as I should. I mean h*(f-g)^2 is a pretty simple operation. Any comments on how to improve the above? In particular on how to build the constant functors h and g? Another question I have is, would it be possible to combine functors with different return types in the same way? Imagine j(x) is now a function that takes in an std::vector<double> and returns an std::vector<double>. Then can it be scaled with a function that takes in an std::vector<double>, but returns a double? BTW, a propos extracting the underlying functor out of a boost::function, yes it isn't ideal, but you might just need to acess the underlying interface at some point. Thanks, ChrisK >

2 1

Re: [Boost-users] [GIL] Performance warning...
by Christian Henning 28 Nov '09

28 Nov '09

Lubomir, looking at the default_channel_converter the channels already arrive as a const reference. All I did was to make sure they are still const references in the channel_converter functions. In all cases the source channels should at least be const. Which allows for more compiler optimizations. I did run the performance test in gil_test suite and the changes were marginal. Some tests were faster some were slower after the change. Christian On Fri, Nov 27, 2009 at 6:13 PM, Lubomir Bourdev <lbourdev(a)adobe.com> wrote: > This was done on purpose. I don't know if it still holds, but it used to be > that a const reference to a simple type like an int or char is slower than > passing the type by value. This is the same reason most STL algorithms take > iterators by value. If you want to make this change it is important to > verify that performance of simple built-in channel types is not adversely > affected. > > Lubomir > > On 11/27/09 12:17 PM, "Christian Henning" <chhenning(a)gmail.com> wrote: > >> Hi Eloi, you're correct and I'll fix that. I can even make it const >> reference. Running the test shows no real difference but that might be >> only because no expensive channels are being used. >> >> I'll commit the changes asap. >> >> Lubomir, please review the changes if your time allows. Affected files >> are channel_algorithm.hpp and gil_concept.hpp. >> >> Thanks, >> Christian >> > >

4 5

GGL Review Results
by Hartmut Kaiser 28 Nov '09

28 Nov '09

Hi all, The review of the Generic Geometry Library is over now. We have had vibrant discussions with regards to the library itself. In addition those stirred up a lot of controversial discussion about the Boosts review process. In this review results I will concentrate on the library at hands. Formally this review ended with 12 YES and 2 NO votes. This result reflects the overall discussion and the general consensus of this library being worth to be included into Boost. Based on this result and the discussions the Generic geometry Library has been formally accepted into Boost. It is worth highlighting that most of the reviewers emphasized the excellent quality of the library design. Here are some quotes: - "The design is very clear. I think it can serve as a standard example of how to cover a big non trivial problem domain using meta-programming, partial specialization and tag dispatch to make it uniformly accessible by a set of generic algorithms." - "The design looks clear enough so that I was able to understand about what was being done. Adding concept checking is a good idea. It also surely is a modern generic design." - "I am quite pleased with the use of tag-dispatching and strategies. I was happy to see this approach taken and by looking at the documentation and source code it seems sound. I believe this approach offers the greatest latitude for a generic library." At the same time the 2 NO votes reflect a couple of shortcomings which still need to be addressed before final inclusion into SVN. Here is a list of contingencies noted by the reviewers: - Robustness: algorithmic robustness and arithmetic stability have been discussed widely. The consensus of the reviewers is that all algorithms need to be robust and that the user should be able to make sure all calculations are arithmetically stable. GGL addresses arithmetic stability by allowing to instantiate all algorithms with arbitrary number types. But it turns out not the entire library has been converted to use this scheme yet. Any design issues that would prevent strong robustness guarantees (without drastic refactoring) in the future should be identified and fixed prior to release. The documentation needs to reflect the actual guarantees and complexities of every algorithm. - Concepts: more refinement needs to be done for the existing concepts. At least 2 users claimed to not have been able to adapt their data structures to the existing scheme. The library aims for defining the concepts and interfaces for future geometry related work in Boost, so these use cases need to be addressed. Users mentioned the missing concept inheritance. This might be a good way to address the current problems of concepts being too fine grained and too difficult to use. What needs to be done at minimum is to enhance the flexibility of the concept mechanism enabling to adapt user provided data structures more easily. The concepts need to be sound even in the light of extensions. - Boolean operations: while the library provides a set of Boolean operations those seem to be not complete and/or robust in terms of clockwise/counterclockwise geometries, closed/open polygons. Robust Boolean operations are a strong requirement, so this should be fixed as reported by at least one reviewer. - Documentation: the documentation of the library is not complete and needs additional effort. Using Doxygen alone as a documentation tool has its (known) shortcomings when it comes to generic libraries. The authors already mentioned to plan to switch to QuickBook after review allowing to have better control over the generated docs. - Testing: several reviewers mentioned the need for a thorough testing framework allowing the verification of the correctness of the algorithms in a wide range of use cases. Different test strategies need to be employed, such as high volume and random tests, known border case tests, tests using different numeric precision types, etc. Minor (non-contingency) issues: - Names of used concepts: currently the library is using mainly terms as established by the OpenGIS Consortium (OGC). This is misleading for users coming from different (non-GIS) domains. It has been suggested to introduce different namespaces for the different geometry domains (GIS, graphics, 3D, etc.) allowing to use the expected terminology established in that particular domain. - Name of the library: the name 'GGL - Generic Geometry Library' is misleading as it is not a generic geometry library but a library using generic programming techniques related to geometry. It has been suggested to use the name Boost.Geometry instead. This is not a requirement imposed by the review results, but I would like to suggest to the authors to consider renaming. - Integration with Boost.Units has been suggested. The library does not need to be completetly integrated with Boost.Units, although it appears to be reasonable to deal with types as exposed by Boost.Units especially for distance and area calculations. - Spatial data structures (such as spatial trees) have been mentioned to be crucial for a geometry related library. While the library can't implement all possible data structures in this field it can (and should) define concepts and interfaces allowing future extensions while maintaining interoperability. - In addition to that the reviewers made a lot of remarks related to different smaller inconsistencies part of which already have been addressed during the review. Barend has a full list of the remaining ones and promised to address all of them. Last but not least I would like to encourage cooperation between the authors of this library and the author of Boost.Polygon as both libraries have their strength' worth combining. In an ideal world and at some point I would like to see both libraries to be merged. But this is obviously not something to expect really soon. At this point I would like to thank all who participated in the review and, certainly, the authors for submitting this excellent library to Boost. Regards Hartmut GGL Review Manager ------------------- Meet me at BoostCon http://boostcon.com

1 0

[serialization] how to serialize map of non-default-constructible?
by ivo.t＠moss-soft.de 28 Nov '09

28 Nov '09

Hi to everybody, I'm pretty new to the list, work for some time with Boost and C++ and have a fair knowledge but am not an expert yet. I try to serialize a map whose type is not default-constructible, and I'm seriously stuck there. I thought the load_construct_data and save_construct_data overrides would help me there, but that seems not to be the case. I tried to create a private default constructor hoping that the map (respectively pair) constructor could access it, due to the boost::serialization::access friend declaration, but that didn't work as well. I really do _not_ want to make a public default constructor. What could I do as a workaround?? Any help would be greatly appreciated!! Btw, I work with Boost 1.39 and Visual Studio 2005. Thank you very much in advance Ivo

3 2

[boost bimap]- question on use of optional sorting predicate for set_of declarations
by Curtis Himel 27 Nov '09

27 Nov '09

I have a question with sorting of sets in the bimap framework. I have a bimap declared thus: //Boost Bimap requires this predicate struct setup struct AreDecalIDsInCorrectRenderOrderStruct { bool operator() (const short nDecalID1, const short nDecalID2) const { //Do comparison } }; typedef boost::bimap<boost::bimaps::unordered_multiset_of<int>, boost::bimaps::set_of<short, AreDecalIDsInCorrectRenderOrderStruct>> intMultisetShortSetBimap; intMultisetShortSetBimap m_mStructureIDToLinkedDecalID; The problem is this isn't working as I expected. I'm expecting that when I insert elements using: m_mStructureIDToLinkedDecalID.insert(intMultisetShortSetBimap ::value_type(nStructureID, nDecalID)); and then later retrieve them using: pair<intMultisetShortSetBimap ::left_const_iterator, intMultisetShortSetBimap ::left_const_iterator> equalRange = m_mStructureIDToLinkedDecalID.left.equal_range(nStructureID); that the retrieved elements with equal range would be sorted according to the predicate I used. But they aren't. Instead their order is dependent on the order they were inserted. I've verified that my predicate is being called on insertions. Am I misunderstanding the purpose of passing a sorting predicate to a set_of declaration? If so, what does the sorting actually do and is there a way to get boost::bimap to do what I want? Thanks for any help. -Curtis _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ This e-mail and any files transmitted with it are confidential and intended solely for the use of the individual or entity to whom they are addressed. If you have received this e-mail in error please notify the originator of the message. This footer also confirms that this e-mail message has been scanned for the presence of computer viruses. Any views expressed in this message are those of the individual sender, except where the sender specifies and with authority, states them to be the views of Indra Systems, Inc.

2 1

[GIL] Performance warning...
by Eloi Du Bois 27 Nov '09

27 Nov '09

Hi all, I am creating a bunch of function for channel merging, thus I was looking in channel_algorithm.hpp and I saw something that may slow down processes... I don't know if I'm right, but on line 362: /// \ingroup ChannelConvertAlgorithm > /// \brief Converting from one channel type to another. > template <typename DstChannel, typename SrcChannel> // Model ChannelConcept > (could be channel references) > inline typename channel_traits<DstChannel>::value_type channel_convert(*SrcChannel > src*) { > return channel_converter<typename > channel_traits<SrcChannel>::value_type, > typename > channel_traits<DstChannel>::value_type>()(src); > } > There is no reference on parameter ***src*.* *That* *not* *a very good idea because references aren't hold by templates function (even if inlined). This may invoke copy constructor and can slow down the processes a "lot"... Here is an example that shows I'm right in theory: // "Slow" on big objects > template<typename P> > inline void testPtr1(P a) { > std::cout << "In called function inequality ptr of a: " << (int)&a << > std::endl; > } > > // Better > template<typename P> > inline void testPtr2(P &a) { > std::cout << "In called function equality ptr of a: " << (int)&a << > std::endl; > } > > template<typename P> > void test(const P & a) { > std::cout << "Base ptr of a: " << (int)&a << std::endl; > testPtr1(a); > } > > int main() { > int a = 0; > test(a); > return 0; > } >

2 1

[bimap] Creating a bimap fom a std::map
by Edward Diener 27 Nov '09

27 Nov '09

I would have thought, naively enough, that one of the common uses of a bimap was that one should be able to create a bimap from a std::map as long as the relation between the two types was unique both ways. I was disconcerted when I did not see a bimap constructor that accepted a std::map of the same types, but then I saw the constructor which takes two iterators and decided to try that, like so: std::map<int,std::string> myMap; // ... fill myMap boost::bimap<int,std::string> myBimap(myMap.begin(),myMap.end()); I was met with, in VC9 using Boost 1.40: "c:\utilities\boost\boost_1_40_0\boost\multi_index_container.hpp(232) : error C2664: 'std::pair<_Ty1,_Ty2> boost::multi_index::multi_index_container<Value,IndexSpecifierList,Allocator>::insert_(const Value &,boost::multi_index::detail::ordered_index_node<Super> *)' : cannot convert parameter 1 from 'std::pair<_Ty1,_Ty2>' to 'const boost::bimaps::relation::mutant_relation<TA,TB,Info,force_mutable> &' 1> with 1> [ 1> _Ty1=boost::multi_index::detail::ordered_index_node<boost::multi_index::detail::ordered_index_node<boost::multi_index::detail::index_node_base<boost::bimaps::relation::mutant_relation<boost::bimaps::tags::tagged<const int,boost::bimaps::relation::member_at::left>,boost::bimaps::tags::tagged<const std::basic_string<wchar_t,std::char_traits<wchar_t>,std::allocator<wchar_t>>,boost::bimaps::relation::member_at::right>,boost::bimaps::detail::manage_additional_parameters<boost::mpl::na,boost::mpl::na,boost::mpl::na>::case_NNN::additional_info,true>,std::allocator<boost::bimaps::relation::mutant_relation<boost::bimaps::tags::tagged<const int,boost::bimaps::relation::member_at::left>,boost::bimaps::tags::tagged<const std::basic_string<wchar_t,std::char_traits<wchar_t>,std::allocator<wchar_t>>,boost::bimaps::relation::member_at::right>,boost::bimaps::detail::manage_additional_parameters<boost::mpl::na,boost::mpl::na,boost::mpl::na>::case_NNN::additional_info,true>>>>> *, 1> _Ty2=bool, 1> Value=boost::bimaps::relation::mutant_relation<boost::bimaps::tags::tagged<const int,boost::bimaps::relation::member_at::left>,boost::bimaps::tags::tagged<const std::basic_string<wchar_t,std::char_traits<wchar_t>,std::allocator<wchar_t>>,boost::bimaps::relation::member_at::right>,boost::bimaps::detail::manage_additional_parameters<boost::mpl::na,boost::mpl::na,boost::mpl::na>::case_NNN::additional_info,true>, 1> IndexSpecifierList=boost::bimaps::detail::bimap_core<int,TString,boost::mpl::na,boost::mpl::na,boost::mpl::na>::core_indices, 1> Allocator=std::allocator<boost::bimaps::relation::mutant_relation<boost::bimaps::tags::tagged<const int,boost::bimaps::relation::member_at::left>,boost::bimaps::tags::tagged<const std::basic_string<wchar_t,std::char_traits<wchar_t>,std::allocator<wchar_t>>,boost::bimaps::relation::member_at::right>,boost::bimaps::detail::manage_additional_parameters<boost::mpl::na,boost::mpl::na,boost::mpl::na>::case_NNN::additional_info,true>>, 1> Super=boost::multi_index::detail::ordered_index_node<boost::multi_index::detail::index_node_base<boost::bimaps::relation::mutant_relation<boost::bimaps::tags::tagged<const int,boost::bimaps::relation::member_at::left>,boost::bimaps::tags::tagged<const std::basic_string<wchar_t,std::char_traits<wchar_t>,std::allocator<wchar_t>>,boost::bimaps::relation::member_at::right>,boost::bimaps::detail::manage_additional_parameters<boost::mpl::na,boost::mpl::na,boost::mpl::na>::case_NNN::additional_info,true>,std::allocator<boost::bimaps::relation::mutant_relation<boost::bimaps::tags::tagged<const int,boost::bimaps::relation::member_at::left>,boost::bimaps::tags::tagged<const std::basic_string<wchar_t,std::char_traits<wchar_t>,std::allocator<wchar_t>>,boost::bimaps::relation::member_at::right>,boost::bimaps::detail::manage_additional_parameters<boost::mpl::na,boost::mpl::na,boost::mpl::na>::case_NNN::additional_info,true>>>> 1> ] 1> and 1> [ 1> _Ty1=const int, 1> _Ty2=TString 1> ] 1> and 1> [ 1> TA=boost::bimaps::tags::tagged<const int,boost::bimaps::relation::member_at::left>, 1> TB=boost::bimaps::tags::tagged<const std::basic_string<wchar_t,std::char_traits<wchar_t>,std::allocator<wchar_t>>,boost::bimaps::relation::member_at::right>, 1> Info=boost::bimaps::detail::manage_additional_parameters<boost::mpl::na,boost::mpl::na,boost::mpl::na>::case_NNN::additional_info, 1> force_mutable=true 1> ] 1> Reason: cannot convert from 'std::pair<_Ty1,_Ty2>' to 'const boost::bimaps::relation::mutant_relation<TA,TB,Info,force_mutable>' 1> with 1> [ 1> _Ty1=const int, 1> _Ty2=TString 1> ] 1> and 1> [ 1> TA=boost::bimaps::tags::tagged<const int,boost::bimaps::relation::member_at::left>, 1> TB=boost::bimaps::tags::tagged<const std::basic_string<wchar_t,std::char_traits<wchar_t>,std::allocator<wchar_t>>,boost::bimaps::relation::member_at::right>, 1> Info=boost::bimaps::detail::manage_additional_parameters<boost::mpl::na,boost::mpl::na,boost::mpl::na>::case_NNN::additional_info, 1> force_mutable=true 1> ] 1> No user-defined-conversion operator available that can perform this conversion, or the operator cannot be called 1> c:\utilities\boost\boost_1_40_0\boost\bimap\bimap.hpp(247) : see reference to function template instantiation 'boost::multi_index::multi_index_container<Value,IndexSpecifierList,Allocator>::multi_index_container<InputIterator>(InputIterator,InputIterator,const boost::tuples::cons<HT,TT> &,const std::allocator<_Ty> &)' being compiled 1> with 1> [ 1> Value=boost::bimaps::relation::mutant_relation<boost::bimaps::tags::tagged<const int,boost::bimaps::relation::member_at::left>,boost::bimaps::tags::tagged<const std::basic_string<wchar_t,std::char_traits<wchar_t>,std::allocator<wchar_t>>,boost::bimaps::relation::member_at::right>,boost::bimaps::detail::manage_additional_parameters<boost::mpl::na,boost::mpl::na,boost::mpl::na>::case_NNN::additional_info,true>, 1> IndexSpecifierList=boost::bimaps::detail::bimap_core<int,TString,boost::mpl::na,boost::mpl::na,boost::mpl::na>::core_indices, 1> Allocator=std::allocator<boost::bimaps::relation::mutant_relation<boost::bimaps::tags::tagged<const int,boost::bimaps::relation::member_at::left>,boost::bimaps::tags::tagged<const std::basic_string<wchar_t,std::char_traits<wchar_t>,std::allocator<wchar_t>>,boost::bimaps::relation::member_at::right>,boost::bimaps::detail::manage_additional_parameters<boost::mpl::na,boost::mpl::na,boost::mpl::na>::case_NNN::additional_info,true>>, 1> InputIterator=std::_Tree<std::_Tmap_traits<int,TString,std::less<int>,std::allocator<std::pair<const int,TString>>,false>>::iterator, 1> HT=boost::tuples::tuple<boost::multi_index::member<boost::bimaps::relation::detail::relation_storage<boost::bimaps::tags::tagged<const int,boost::bimaps::relation::member_at::left>,boost::bimaps::tags::tagged<const std::basic_string<wchar_t,std::char_traits<wchar_t>,std::allocator<wchar_t>>,boost::bimaps::relation::member_at::right>,true>,std::basic_string<wchar_t,std::char_traits<wchar_t>,std::allocator<wchar_t>>,pointer-to-member(0x4)>,std::less<std::basic_string<wchar_t,std::char_traits<wchar_t>,std::allocator<wchar_t>>>>, 1> TT=boost::tuples::cons<boost::tuples::tuple<boost::multi_index::member<boost::bimaps::relation::detail::relation_storage<boost::bimaps::tags::tagged<const int,boost::bimaps::relation::member_at::left>,boost::bimaps::tags::tagged<const std::basic_string<wchar_t,std::char_traits<wchar_t>,std::allocator<wchar_t>>,boost::bimaps::relation::member_at::right>,true>,int,pointer-to-member(0x0)>,std::less<int>>,boost::multi_index::detail::index_base<boost::bimaps::relation::mutant_relation<boost::bimaps::tags::tagged<const int,boost::bimaps::relation::member_at::left>,boost::bimaps::tags::tagged<const std::basic_string<wchar_t,std::char_traits<wchar_t>,std::allocator<wchar_t>>,boost::bimaps::relation::member_at::right>,boost::bimaps::detail::manage_additional_parameters<boost::mpl::na,boost::mpl::na,boost::mpl::na>::case_NNN::additional_info,true>,boost::bimaps::detail::bimap_core<int,TString,boost::mpl::na,boost::mpl::na,boost::mpl::na>::core_indices,std::allocator<boost::bimaps::relation::mutant_relation<boost::bimaps::tags::tagged<const int,boost::bimaps::relation::member_at::left>,boost::bimaps::tags::tagged<const std::basic_string<wchar_t,std::char_traits<wchar_t>,std::allocator<wchar_t>>,boost::bimaps::relation::member_at::right>,boost::bimaps::detail::manage_additional_parameters<boost::mpl::na,boost::mpl::na,boost::mpl::na>::case_NNN::additional_info,true>>>::ctor_args_list>, 1> _Ty=boost::bimaps::relation::mutant_relation<boost::bimaps::tags::tagged<const int,boost::bimaps::relation::member_at::left>,boost::bimaps::tags::tagged<const std::basic_string<wchar_t,std::char_traits<wchar_t>,std::allocator<wchar_t>>,boost::bimaps::relation::member_at::right>,boost::bimaps::detail::manage_additional_parameters<boost::mpl::na,boost::mpl::na,boost::mpl::na>::case_NNN::additional_info,true> 1> ] 1> c:\programming\programs\vc9\xxx\current\yyyyyyyyyy\zzzzzzzzzzzzzzzz.cpp(338) : see reference to function template instantiation 'boost::bimaps::bimap<KeyTypeA,KeyTypeB>::bimap<std::_Tree<_Traits>::iterator>(InputIterator,InputIterator)' being compiled 1> with 1> [ 1> KeyTypeA=int, 1> KeyTypeB=TString, 1> _Traits=std::_Tmap_traits<int,TString,std::less<int>,std::allocator<std::pair<const int,TString>>,false>, 1> InputIterator=std::_Tree<std::_Tmap_traits<int,TString,std::less<int>,std::allocator<std::pair<const int,TString>>,false>>::iterator 1> ]" So evidently that does not work. What is the problem with creating a bimap from the data in a std::map ? It seems as if it should be a no-braine and one of the chief selling points of using a bimap.

4 10

Compiler warnings from Macs, IBM acc, Borland, Comeau, Metroworks, et al - are they a Problem?
by Paul A. Bristow 27 Nov '09

27 Nov '09

https://svn.boost.org/trac/boost/wiki/Guidelines/MaintenanceGuidelines (bottom of the page) has a collection of suggestions for 'quieting' warnings on MSVC and GCC, but no information on other compilers yet. Can users of these compilers please 1 Assert that they never have a problem with unhelpful compiler warnings from Boost stuff, or 2 Send common warnings and suggestions for dealing with them by suppressing or by 'fixing' the code (so that I can add to the guidelines. Thanks Paul --- Paul A. Bristow Prizet Farmhouse Kendal, UK LA8 8AB +44 1539 561830, mobile +44 7714330204 pbristow(a)hetp.u-net.com

2 1

[boost serialization] Build SQL database from data in web pages
by Boost lzw 27 Nov '09

27 Nov '09

Hello folks, I am wondering if I can use boost, boost serialization in particular, to build a SQL database from data in web pages. For example, I want to build a SQL database based on data from web page link such as this one: http://tubic.tju.edu.cn/deg/information.php?ac=DEG10010001 Since the data would be collected from thousands of such link, I want to write code for doing it automatically. Can anyone suggest how to do it with boost? Thanks a lot in advance, Robert

3 2

Re: [Boost-users] gcc problems on mac os 10.6...
by Wong Hua 27 Nov '09

27 Nov '09

Thanks for the answer ! It seems that you have a custom Python installed in /Library/Frameworks/Python. framework, and the build process prefers this one instead of the "system" /System/Library/Frameworks/Python.framework. When I installed the custom 2.5 one from python.org, I had the same error, because the build process picked up this custom install of Python. I uninstalled it, and the build picked up the system python, which worked well. The thing is that the Python from Python.org is 32 bits. The python installed with mac os 10.6 is 64 bits. I checked that using : >>>import struct >>>struct.calcsize("P")*8 Returns 32 on the python installed from python.org (in fact you have to specify you want a 64 bit python when configuring I think)

2 1

uuid?
by Maróy Ákos 27 Nov '09

27 Nov '09

Hi, I searched through the boost-users mailing list archives, and found a few references of a to-be-released uuid implementation, but nothing really tangilbe. Is there a uuid implementation available under or around boost? Thanks, Akos

9 13

Re: [Boost-users] BOOST_FOREACH and boost::bimap
by pete＠pcbartlett.com 27 Nov '09

27 Nov '09

On Fri 27/11/09 08:08 , Conoscenza Silente <abruzzoforteegentile(a)gmail.com> wrote: > Hi All > I tried to use BOOST_FOREACH with bimap but it doesn't compile. .. > BOOST_FOREACH( BMapKIt it, myBimap) // this line doesnt' ... Bimap is no different from any other container when it comes to FOREACH, you need "BMapVal v" not "BMapKlt it" in the macro.

2 1

[Statechart] How to model this scenario?
by Zachary Turner 27 Nov '09

27 Nov '09

Suppose I have a character in a game. He can run, and do two types of attacks. He can initiate either an attack first or a jump first, and then initiate the other second and it will perform both at the same time until one finishes, then go back to just one until that one is also finished, and finally go back to just running on the ground. Additionally, he can be knocked back either on the ground or while already in the air. The system has the following properties: - If he is attacking (regardless of whether it be on the ground or in the air), he cannot initiate another attack until the first one is done. Otherwise he can always initiate an attack (even in the air). - If he is jumping, he cannot jump again until the first jump is finished. - Regardless of whether he is jumping or on the ground, he can initiate attack 1, initiate attack 2, or jump. All of this is only possible if he is not currently being knocked back. - There are separate animations for: jumping attack 1 while on the ground attack 2 while on the ground attack 1 while jumping attack 2 while jumping knockback If being knocked back, the knockback animation takes priority over whatever other animation was being played at the time. After the knockback is complete, it will continue from the previous animation, assuming that state has not finished. I feel like I should use some type of concurrent states here, but I'm not sure how to model the combinatorial factor (i.e. playing different animations depending on the *combination* of states). I'm also not sure how to model the priority of the knockback animation. In fact, this is not just related to the Statechart library, but I'm unclear how to do this using UML State Machines as well. Any advice appreciated. Zach

2 1

finite state machine performance info
by Conoscenza Silente 27 Nov '09

27 Nov '09

Hi All Yesterday I started playing with Boost State Chart library implementing state machines for my applications. Each time I am moving into a new state I noticed that a new state is created; this means that the constructor of the boost::statechart::state class is called each time ( and the destructor for the state that I am leaving ). I would like to fasten up the whole process; let's say that I would like to avoid the creation/destruction of the class each time using object already allocated in memory that are deleted only at the exit of the application. Is this a good way in your opinion ? I saw that there is an allocator template argument but at the state where I am now I would lilke to not spend time in doing a new allocator for that: do you know if there already in place something that I can reuse for my purpose? Thanks CS

5 9

Re: [Boost-users] Automating Serialization?
by Brian Wood 27 Nov '09

27 Nov '09

Stefan Strasser writes: >Am Thursday 26 November 2009 14:05:18 schrieb Bilokon, Paul: >> Hi, >> >> By design Boost Serialization requires the user to list each field that >> needs to be serialised. >> >> This is in contrast, for example, with Java and some other languages where >> serialisation is supported (kind of) at the language level. >> >> The current approach requires some code duplication. We have to declare a >> field. We have to manually (de)serialise it. If we need to make a change, >> we make it in at least two distinct places. >> >> Is there any way to automate the process of serialisation, perhaps >> harnessing the power of the preprocessor? E.g. we could label the fields >> that need to be serialised. Is there anything in Boost that could help? > >not that I'm aware of, but I even think that's a good thing. >the serialize() function represents a file format, and you want file formats >to be stable and not being changed because someone added a runtime field to a >class. "runtime field" ? >usually when you do want to add a serialized field you'd also want old >versions of the file still to be readable, so you end up writing custom >(versioned) deserialization code anyway, even if your language has built-in >serialization support. I recommend avoiding the versioning support in Boost Serialization. It runs counter to good development practices by averting the type system. Consider for example a class called Account that uses versioning to support multiple releases of a product. In the usual case, later releases will have more fields and added complexity than earlier releases. Support then for a client at an early release, say 1.1, becomes inefficient since Account is being used to handle both 1.2 and 1.1 users. If instead Account_11 and Account_12 are used -- with Account_12 probably derived from Account_11 -- this weakness is avoided. Additionally this approach is beneficial from a testing perspective. In a 1.2 server, 1.1 clients are supported using Account_11, which has already been tested and is not messed with to support 1.2 clients. > >you could use some compile time code generator to write default serialization >code for you, using e.g. OpenC++, GCC-XML, or Doxygen, but I doubt those >generated functions would stay there very long. I'm not exactly sure what you are saying here, but if a user is simply improving the names of some of his fields, the functions won't stay the same very long. Automating this helps with a common problem of forgetting to update the serialization functions and the compiler then barking. I don't claim though that every class should be handled this way. The C++ Middleware Writer allows users to turn off the automated generation of marshalling functions if that is desired. In my experience, it is unusual to turn that functionality off. Regards, Brian Wood http://www.webEbenezer.net <http://www.webebenezer.net/> "Then Samuel took a stone, and set it between Mizpeh and Shen, and called the name of it Ebenezer, saying, so far the the L-RD has helped us."

2 1

BOOST_FOREACH and boost::bimap
by Conoscenza Silente 27 Nov '09

27 Nov '09

Hi All I tried to use BOOST_FOREACH with bimap but it doesn't compile. What is wrong in using it the way is displayed below? Reading the specs it should be able to work since bimap provide .begin() and .end() methods. Thanks CS typedef boost::bimap<int,std::string > BMap; typedef boost::bimap<int,std::string >::value_type BMapVal; typedef boost::bimap<int,std::string >::const_iterator BMapKIt; BMap myBimap; myBimap.insert( BMapVal( 10, "hi") ); myBimap.insert( BMapVal( 20, "hihihi") ); BOOST_FOREACH( BMapKIt it, myBimap) // this line doesnt' compile: { std::cout << "LEFT: " << it->left << " RIGHT: " << it->right << std::endl; } TestBoost_Nov26.h:68: error: conversion from ‘boost::bimaps::relation::mutant_relation<boost::bimaps::tags::tagged<const int, boost::bimaps::relation::member_at::left>, boost::bimaps::tags::tagged<const std::basic_string<char, std::char_traits<char>, std::allocator<char> >, boost::bimaps::relation::member_at::right>, mpl_::na, false>’ to non-scalar type ‘boost::bimaps::detail::set_view_iterator<boost::multi_index::detail::bidir_node_iterator<boost::multi_index::detail::ordered_index_node<boost::multi_index::detail::index_node_base<boost::bimaps::relation::mutant_relation<boost::bimaps::tags::tagged<const int, boost::bimaps::relation::member_at::left>, boost::bimaps::tags::tagged<const std::basic_string<char, std::char_traits<char>, std::allocator<char> >, boost::bimaps::relation::member_at::right>, mpl_::na, true>, std::allocator<boost::bimaps::relation::mutant_relation<boost::bimaps::tags::tagged<const int, boost::bimaps::relation::member_at::left>, boost::bimaps::tags::tagged<const std::basic_string<char, std::char_traits<char>, std::allocator<char> >, boost::bimaps::relation::member_at::right>, mpl_::na, true> > > > > >’ requested

1 0

[interprocess] file_lock permission denied
by Trigve Siver 27 Nov '09

27 Nov '09

Hi, I'm trying to use file_lock from interprocess but without success. Here is code I'm using: m_Stream.exceptions(std::ios::badbit); m_Stream.open(m_FileName.c_str()); boost::interprocess::file_lock lock(m_FileName.c_str()); ... { // Lock file boost::interprocess::scoped_lock<boost::interprocess::file_lock> scoped_file_lock(lock); // Write to stream m_Stream << "Some text"; m_Stream.flush(); } where m_Stream is std::ofstream. When "m_Stream.flush()" is executed, I've got a "badbit" exception with "errno" 0x001b0800 and message (with strerror()) "Permission denied". I've tried also with win32 CreateFile()/WriteFile() but without success. I'm using boost 1.40, Visual Studio 2005 SP1, Vista 32 bit SP2 Thanks Trigve

1 0

Re: [Boost-users] Automating Serialization?
by Brian Wood 27 Nov '09

27 Nov '09

Emil Dotchevski writes: >On Thu, Nov 26, 2009 at 5:05 AM, Bilokon, Paul <paul.bilokon(a)citi.com> wrote: > >> The current approach requires some code duplication. We have to declare a >> field. We have to manually (de)serialise it. If we need to make a change, we >> make it in at least two distinct places. > > You are thinking in terms of reflection. Think in terms of states and > invariants and it'll make more sense. For example, if you have an > array of items and a pointer, and your invariant is that the pointer > always points the last element in the array, the pointer should not be > serialized. > I don't know if that is a common situation, but there are two ways to handle that with the C++ Middleware Writer. One as I mentioned in another post is to turn off the automatic generation of marshalling functions. The other is to place those fields which shouldn't be included in the marshalling process within an #ifdef SERVER_SIDE -- http://webEbenezer.net/ifdefSERVER.html . The macro is turned on when servers are built and off when clients are built. This approach enables servers to have a complete view of a type and clients to have an accurate, but limited view of the same type. Regards, Brian Wood http://www.webEbenezer.net <http://www.webebenezer.net/> "Then Samuel took a stone, and set it between Mizpeh and Shen, and called the name of it Ebenezer, saying, so far the the L-RD has helped us."

1 0

using uint8_t & the like on open solaris
by Maróy Ákos 27 Nov '09

27 Nov '09

Mikko, > You could try > using boost::uint8_t; This is what I wanted to avoid. looking at the issue further, it seems that solaris doesn't have the <stdint> C++ include, only the <stdint.h> C include, and thus these definitions are incolded from there, into the global namespace. as a solution, <boost/cstdint.hpp> could put the contents of the <stdint.h> C include into the std namespace explicitly, to increase C++ compliance - as the C includ would be unaware of namespaces anyway. another workaround is to specify using boost::uint8_t; before usage. Akos

1 0