- Boost - lists.boost.org

[optional] copy-initialization?
by shunsuke 19 Sep '07

19 Sep '07

Hi, Could you see the following tests: #include <boost/optional/optional.hpp> #include <cassert> int main() { { int const i = 10; boost::optional<int const &> o(i); assert(*o == 10); assert(&*o == &i); // ok } { int const i = 10; boost::optional<int const &> o = i; // copy-initialization assert(*o == 10); assert(&*o == &i); // failed on gcc3.4 and 4.1. } } For some reason, msvc passes this. Is this a bug, or copy-initialization is prohibited? Regards, -- Shunsuke Sogame

1 0

pass data between two layers (req. of patterns)
by Oliver.Kowalke＠qimonda.com 19 Sep '07

19 Sep '07

Hello, what would be a good practice to pass data between two layers. The upper layer invokes functionality of the lower layer and vice versa. One solution could be to implement the two layers as singletons which memebr functions implement the provided functionalities of the layer. But this would result in unreadable code. Do you have better suggestions (patterns)? Regards, Oliver

1 0

Re: [boost] Simple object factory: Checking signatures at runtime
by Steven Watanabe 19 Sep '07

19 Sep '07

AMDG "Marco Costalba" <mcostalba(a)gmail.com> wrote: > Sorry, but I don't understand, could you please post an example of how > to use the dispatcher so to see 'struct implicit_conversion' at work ? > > Thanks > Marco > The code I posted was not well thought out. The set of implicit conversions should probably be global. I would want to write make_implicit_conversion<double, int>(); make_implicit_conversion<int, double>(); Somewhere during initialization to say that int is convertible to double and double to int. Here's a more complete implementation (warning untested) I'm not showing how to register functions. That would involve creating a function object that casts from void* to the actual type. A real implementation would probably also use Boost.Function instead of function pointers. struct wrap_typeinfo { friend bool operator<(const wrap_typeinfo& lhs, const wrap_typeinfo& rhs) { return(lhs.key.before(rhs.key)); } const std::type_info* impl; }; struct implicit_conversion { friend bool operator<(const implicit_conversion& lhs, const implicit_conversion& rhs) { return(lhs.from.before(rhs.from)); } const std::type_info* to; void* (*convert)(void*); void (*destroy)(void*); }; static std::multi_map<wrap_typeinfo, implicit_conversion> all_conversions; void* ignore_convert(void* x) { return(x); } void ignore_destroy(void*) {} static implicit_conversion no_conversion = { 0, 0, &ignore_convert &ignore_destroy }; template<class To> void destroy(void* victim) { delete static_cast<To*>(victim); } template<class From, class To> void* convert(void* from) { return new To(*static_cast<From*>(from)); } template<class From, class To> void make_implicit_conversion() { wrap_typeinfo from = { &typeid(From) }; implicit_conversion result = { &typeid(To), &convert<From, To>, &destroy<From, To> }; all_conversions.insert(std::make_pair(from, result)); } template<class R> struct dispatcher0 { public: R operator()() const { return(f0()); } private: R (*f0)(); }; template<class F> F get_function(F f, const std::type_info**, const implicit_conversion**) { return(f); } template<class F, class T> F get_function(const std::map<wrap_typeinfo, T>& m, wrap_typeinfo* types, const implicit_conversion** out) { std::map<wrap_typeinfo, T>::iterator iter = m.find(*types); if(iter != m.end()) { ++types; *out++ = &no_conversion; return(get_function<F>(t.value, types, out)); } else { BOOST_FOR_EACH(const implicit_conversion& conversion, all_conversions.equal_range(*types)) { std::map<wrap_typeinfo, T>::iterator iter = m.find(*conversion.from); if(iter != m.end()) { ++types; *out++ = &conversion; return(get_function<F>(iter->second, types, out)); } } } return(0); } template<int N> struct cleanup_array : cleanup_array<N - 1> { cleanup_array(implicit_conversion* c, void** data) : cleanup_array<N - 1>(c) { x = c[N - 1].convert(data[N-1]); } ~cleanup_array() { cleanup_array<N - 1>::conversions[N-1].destroy(x); } void* x; }; template<> struct cleanup_array<0> { implicit_conversion* conversions; cleanup_array(implicit_conversion* c, void**) : conversions(c) {} }; template<int N, int N2> void* get(cleanup_array<N2>& from) { return(static_cast<cleanup_array<N+1>&>(from).x); } template<class R> struct dispatcher1 { public: template<class T0> R operator()(T0 t0) const { wrap_typeinfo types[1] = { &typeid(T0) }; implicit_conversion* conversions[1]; R (*f)(void*) = get_function<R(*)(void*)>(f1, types, conversions); void* elements[1] = { &t0 }; cleanup_array<1> data(conversions, elements); return(f(get<0>(data))); } private: std::map<wrap_typeinfo, R(*)(void*)> f1; }; template<class R> struct dispatcher2 { public: template<class T0, class T1> R operator()(T0 t0, T1 t1) const { wrap_typeinfo types[2] = { &typeid(T0), &typeid(T2) }; implicit_conversion* conversions[2]; R (*f)(void*) = get_function<R(*)(void*, void*)>(f2, types, conversions); void* elements[2] = { &t0, &t1 }; cleanup_array<2> data(conversions, elements); return(f(get<0>(data), get<1>(data))); } private: std::map<wrap_typeinfo, std::map<wrap_typeinfo, R(*)(void*, void*)> > f2; }; In Christ, Steven Watanabe

3 4

[fusion::vector] Forwarding packed arguments by reference
by Marco Costalba 19 Sep '07

19 Sep '07

In a object factory I'm converting to using boost::fusion I have a problem with passing argument by reference with a fusion vector. Let's explaing a bit... UI function to get an object from a name and a list of c'tor arguments is something like template<typename T1> /* one argument case */ static Base* object(detail::KeyRef nm, T1 a1) { typedef boost::fusion::vector<T1> values; values v(boost::fusion::vector_tie(a1)); return detail::Factory_p<Base>::instance(). template doObject<values>(nm, v); } template<typename T1, typename T2> /* two arguments case */ static Base* object(detail::KeyRef nm, T1 a1, T2 a2) { typedef boost::fusion::vector<T1, T2> values; values v(boost::fusion::vector_tie(a1, a2)); return detail::Factory_p<Base>::instance(). template doObject<values>(nm, v); } I want to easy the user from the burden to specifying template parameters, so use template parameters deduction. Because of function templates does not support template default arguments we are forced to use one of the above template for each number of arguments. Although we have many UI 'object()' templates I would like to use only one doObject<> template to avoid duplicating all the inner workings of the factory for each argument number. To do this input arguments are 'packed' in a fusion vector and unpacked just before to invoke the function object that actually creates the object: template<typename Values> Base* doObject(KeyRef nm, Values& v) const { --- cut-- const SignatureClass<Base, Values>* p = this->find<Values>(r); if (p) return (*p)(v); -- cut --- } Where the operator() in (overloaded) SignatureClass is defined as: template<typename Base, typename Values typename FnType> struct CreatorClass: public SignatureClass<Base, Values> { typedef typename FnType::result_type result_type; CreatorClass(const FnType& fn) : functor(fn) {} virtual result_type operator()(Values& v) const { return boost::fusion::invoke_function_object(functor, v); } FnType functor; }; Now the problem is that I'm not able to find a way to pass arguments by reference. As example, if I have a class: class Test { public: Test(int& cnt) { cnt++; } }; trying the following will fail: int objCnt = 6; Test* t = Factory::object(objCnt); cout << objCnt; // Is still 6 not 7!! This is expected since I pass by copy in object(detail::KeyRef nm, T1 a1) But it fails to update objCnt also if I explicitly set the template parameter type: Test* t = Factory::object<int&>(objCnt); How can I modify the code above to let pack arguments in a vector, handling always passing the packed vector by reference and finally call invoke_function_object() ? Thanks Marco

2 7

[filesystem] svn trunk broken
by Neal Becker 19 Sep '07

19 Sep '07

gcc-4.1.2 ./boost/filesystem/operations.hpp:1001: error: passing ‘const boost::filesystem::basic_path<std::basic_string<char, std::char_traits<char>, std::allocator<char> >, boost::filesystem::path_traits>’ as ‘this’ argument of ‘boost::filesystem::basic_path<String, Traits>& boost::filesystem::basic_path<String, Traits>::remove_leaf() [with String = std::basic_string<char, std::char_traits<char>, std::allocator<char> >, Traits = boost::filesystem::path_traits]’ discards qualifiers

3 2

Re: [boost] [Boost-users] Review wizard's report for October 2007
by Ronald Garcia 18 Sep '07

18 Sep '07

On Sep 15, 2007, at 5:04 PM, Tobias Schwinger wrote: > Ronald Garcia wrote: >> >> >> Exception >> --------- >> :Author: Emil Dotchevski > > >> :Review Manager: Need Volunteer > > I'm, interested. As my time is limited right now, I'd need some for > proper pre-review inspection, though. > Thank you for volunteering. Could you give me a sense of how much time you would need before you could schedule a review? > >> Libraries under development >> =========================== >> >> Please let us know of any libraries you are currently >> developing that you intend to submit for review. > > The Boost X-files vol. 1, a collection of various utilities. > > http://tinyurl.com/ynjq2n > > It contains some function objects, such as a brute-force solution > to the > forwarding problem (to be factored out of Fusion) and generic > factories. > Further, and most notably, it includes three thread-safe Singleton > templates with an easy-to-use, "Boost-style" interface. > > It's almost in review-ready state, so given the number of entries > we can > probably put it in the queue right now. > Thanks for the information. I will add X-Files to the review queue. I would like to list the three libraries (factory, singleton, and forward) as separate reviews. I think that this would make sense for the purpose of reviewing. Let me know if there is some reason to review all three simultaneously. ron

2 2

[function] Merits of drop-in replacement
by Michael Marcin 18 Sep '07

18 Sep '07

I ran across http://www.codeproject.com/cpp/fastdelegate2.asp the other day. I searched the archives and didn't find any discussion about it on the list. It makes some good arguments and seems to be done pretty well, although it may have succumb to a bit of feature creep. Should those benchmarks be reran against the trunk version of Boost.Function? Thanks, Michael Marcin

4 5

[asio] wrapping handler with tuple in serialization example, client.cpp, connection.hpp
by Chris Fairles 18 Sep '07

18 Sep '07

In svn, the serialization example wraps a mem func ptr in a tuple to be tossed through various bind calls. In client.cpp, I found that using boost::protect around the bind call prevents the compile errors but I'm not sure why. connection_.async_read(stocks_, boost::protect(boost::bind(&client::handle_read, this, boost::asio::placeholders::error))); Any ideas as to why this works?

2 1

[serialization] suggestion: specialize make_nvp to create nvp<T> only if using basic_xml_i/oarchive
by Chris Fairles 18 Sep '07

18 Sep '07

I wanted the ability to serialize to binary archives (over a socket) and xml archives (file) without writing code for the two cases (nvp w/xml and no-nvp with non-xml). I whipped up a quick make_nvp wrapper that simply forwards on the value if not serializing to a xml archive. Others might find this useful, not sure if its good behavior to have right in the library. It does require adding the Archive type as a tempalte param to the make_nvp call. template <typename Archive, typename T> struct make_nvp_impl { typedef T& result_type; static T& do_make_nvp(const char *tag, T & value) { return value; } }; template <typename Archive, typename T> struct make_nvp_impl<boost::archive::basic_xml_iarchive<Archive>, T> { typedef boost::serialization::nvp<T> result_type; static boost::serialization::nvp<T> do_make_nvp(const char *tag, T & value) { return boost::serialization::make_nvp(tag,value); } }; template <typename Archive, typename T> struct make_nvp_impl<boost::archive::basic_xml_oarchive<Archive>, T> { typedef boost::serialization::nvp<T> result_type; static boost::serialization::nvp<T> do_make_nvp(const char *tag, T & value) { return boost::serialization::make_nvp(tag,value); } }; template <typename Archive, typename T> typename make_nvp_impl<Archive, T>::result_type make_nvp(const char* tag, T& value) { return make_nvp_impl<Archive,T>::do_make_nvp(tag,value); } So now: struct point { int x, y; template<class Archive> void serialize(Archive &ar, const unsigned int /*version*/) { ar & make_nvp<Archive>("x",x); ar & make_nvp<Archive>("y",y); } }; will serialize properly for xml archives and non-xml archives. Chris

2 3

Help wanted: regression tests xsl maintenance
by Beman Dawes 18 Sep '07

18 Sep '07

The Boost regression test results at http://beta.boost.org/development/tests/trunk/developer/summary.html are generated via xsl. The xsl files are found located at boost-root\tools\regression\xsl_reports\xsl\v2. We want to make a very small addition to the reports, but the folks at Meta-comm who wrote these files are unavailable. That points out a second problem; as long as the folks at Meta-comm are the only ones who understand these files enough to make changes, we've got a single point of possible failure, and that's uncomfortable. So we are looking for xsl knowledgeable volunteers to work with Rene, me, and the other folks on the testing list to do simple maintenance tasks on these files and our test reporting system. Any takers? --Beman

3 3