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

How am I misusing boost::lambda::bind?
by Jason House 05 Jan '07

05 Jan '07

I hope the sheer size of this post doesn't scare those who can help me away :( Depending on how I use the code at the bottom of this post, things either work or they blow up with varying error messages deep within the boost libraries. The very last function in the code below is the last consistent "source" of the errors. As best as I understand it, that line is correct. I'm scratching my head on how to diagnose what's going wrong. The simplest error I got seemed to complain about const qualifiers that seem to have been added internally to boost::lambda::bind. I'm not sure which error message to pick out from other error scenarios (such as 3 input parameters (types T0, T1, and T2)). This error had R0=void, and no input arguments (T0, T1, etc...). The code at the bottom of this post compiles with R0=void and T0=int. actions.hpp:87: error: no matching function for call to ‘boost::lambda::function_adaptor< GTPInternalResponse (*)( boost::function0<void, std::allocator<boost::function_base> >*, GTPCommand)> ::apply( GTPInternalResponse (* const&)( boost::function0<void, std::allocator<boost::function_base> >*, GTPCommand), boost::function0<void, std::allocator<boost::function_base> >* const&)’ As clarification for understanding the code: GTPInternalResponse can be thought of a string and GTPCommand as a tokenized string. The extract<>() function consumes some string tokens and returns a value of the specified type (T0,T1,T2,T3, etc...) The only big impact on this code externally (besides the calls to GTPFunctionObjectN) is #define's for GTP_PARAM_COUNT and GTP_PARAM_COUNT_PLUS_ONE. GTP_PARAM_COUNT_PLUS_ONE == GTP_PARAM_COUNT. The useful range for GTP_PARAM_COUNT is between 0 and 3 (inclusive). > #include <boost/preprocessor/enum_params.hpp> // expands for 0 ... N-1 > #include <boost/preprocessor/repetition/enum_shifted_params.hpp> // expands for 1 ... N-1 > > #if GTP_PARAM_COUNT == 0 > # define GTP_OPTIONAL_COMMA > #else > # define GTP_OPTIONAL_COMMA , > #endif > > > // GTP_PARMS expands to " typename T0, typename T1, typename T2" if GTP_PARAM_COUNT is 3 > #define GTP_TEMPLATE_PARAMS BOOST_PP_ENUM_PARAMS(GTP_PARAM_COUNT, typename T) > > // expands to "typename R0 , typename T0, typename T1, typename T2" if GTP_PARAM_COUNT is 3 > #define GTP_FULL_TEMPLATE_PARAMS typename R0 GTP_OPTIONAL_COMMA GTP_TEMPLATE_PARAMS > > // GTP_PARAM expands to " T3 a3" if INDEX is 3 > #define GTP_PARAM(UNKNOWN1,INDEX,UNKNOWN2) BOOST_PP_CAT(T,I) BOOST_PP_CAT(a,I) > > // GTP_PARAMS expands to " T0 a0, T1 a1, T2 a2" if GTP_PARAM_COUNT is 3 > #define GTP_PARAMS BOOST_PP_ENUM(GTP_PARAM_COUNT,GTP_PARAM,BOOST_PP_EMPTY) > > // GTP_PARAM_TYPES expands to " T0, T1, T2" if GTP_PARAM_COUNT is 3 > #define GTP_PARAM_TYPES BOOST_PP_ENUM_PARAMS(GTP_PARAM_COUNT, T) > > // expands to "R0 , T0, T1, T2" if GTP_PARAM_COUNT is 3 > #define GTP_FULL_PARAM_TYPES R0 GTP_OPTIONAL_COMMA GTP_PARAM_TYPES > > // GTP_PARAM_NAMES expands to " a0, a1, a2" if GTP_PARAM_COUNT is 3 > #define GTP_PARAM_NAMES BOOST_PP_ENUM_PARAMS(GTP_PARAM_COUNT, a) > > // expands to "boost::function3 < R0 , T0, T1, T2 >" when GTP_PARAM_COUNT is 3 > #define GTP_BOOST_FUNCTION BOOST_PP_CAT(boost::function,GTP_PARAM_COUNT) < GTP_FULL_PARAM_TYPES > > > // expands to "boost::function3 < void , T0, T1, T2 >" when GTP_PARAM_COUNT is 3 > #define GTP_BOOST_FUNCTION_VOID BOOST_PP_CAT(boost::function,GTP_PARAM_COUNT) < void GTP_OPTIONAL_COMMA GTP_PARAM_TYPES > > > // expands to type_wrapper3 when GTP_PARAM_COUNT is 3 > #define GTP_TYPE_WRAPPER BOOST_PP_CAT(type_wrapper,GTP_PARAM_COUNT) > > ////////////////////////////////////////////////////////////// > // gtp_detail::type_wrapper for converting all input arguments > namespace gtp_detail{ > > template < GTP_FULL_TEMPLATE_PARAMS > > struct GTP_TYPE_WRAPPER{ > static GTPInternalResponse wrap(GTP_BOOST_FUNCTION *(callback_function), GTPCommand cmd){ > unsigned int position = 0; > /// \bug Must figure out how to auto generate this repetative body > #if GTP_PARAM_COUNT >= 1 > assert(position < cmd.GetArgumentCount()); > T0 a0 = extract<T0>(cmd, position); > #endif > #if GTP_PARAM_COUNT >= 2 > assert(position < cmd.GetArgumentCount()); > T1 a1 = extract<T1>(cmd,position); > #endif > #if GTP_PARAM_COUNT >= 3 > assert(position < cmd.GetArgumentCount()); > T2 a2 = extract<T2>(cmd,position); > #endif > assert(position == cmd.GetArgumentCount()); > return converter<R0, GTPInternalResponse>( (*callback_function)(GTP_PARAM_NAMES) ); > } > }; > > template < GTP_TEMPLATE_PARAMS > > struct GTP_TYPE_WRAPPER < void GTP_OPTIONAL_COMMA GTP_PARAM_TYPES >{ > static GTPInternalResponse wrap(GTP_BOOST_FUNCTION_VOID *(callback_function), GTPCommand cmd){ > unsigned int position = 0; > /// \bug Must figure out how to auto generate this repetative body > #if GTP_PARAM_COUNT >= 1 > assert(position < cmd.GetArgumentCount()); > T0 a0 = extract<T0>(cmd, position); > #endif > #if GTP_PARAM_COUNT >= 2 > assert(position < cmd.GetArgumentCount()); > T1 a1 = extract<T1>(cmd,position); > #endif > #if GTP_PARAM_COUNT >= 3 > assert(position < cmd.GetArgumentCount()); > T2 a2 = extract<T2>(cmd,position); > #endif > assert(position == cmd.GetArgumentCount()); > (*callback_function)(GTP_PARAM_NAMES); > return GTPInternalResponse(); > } > }; > > }; > > /////////////////////////////////////////////////////// > // GTPCommandCallBack accepting a boost function object > > // expands to GTPFunctionObject3 when GTP_PARAM_COUNT is 3 > #define GTP_COMMAND_CALLBACK BOOST_PP_CAT(GTPCommandCallBack,GTP_PARAM_COUNT) > > // expands to " boost::lambda::_1, boost::lambda::_2, boost::lambda::_3" if GTP_PARAM_COUNT is 3 > #define GTP_LAMBDA_PARAMS BOOST_PP_ENUM_SHIFTED_PARAMS(GTP_PARAM_COUNT_PLUS_ONE, boost::lambda::_) > > template< GTP_FULL_TEMPLATE_PARAMS > inline > GTPFunctionObject* GTP_COMMAND_CALLBACK(GTP_BOOST_FUNCTION *callback_function){ > return new GTPFunctionObject(boost::lambda::bind((&gtp_detail::GTP_TYPE_WRAPPER<GTP_FULL_PARAM_TYPES>::wrap), callback_function GTP_OPTIONAL_COMMA GTP_LAMBDA_PARAMS)); > }

3 3

[spirit] closures and actions
by Hugh Hoover 04 Jan '07

04 Jan '07

I'm trying to build a parser that does a fairly simple transformation of an input string - kind of like an L-System. I can get rules to properly match the input string, but I'm having real trouble with DOING anything. For testing, I've created some simple actions and a grammar (and rules) with a closure. When I don't use the closure for "temporary" variables, I seem to be able to proceed, but when I do anything except assign a value to my closure result, I'm getting failures to compile. This is using gcc4.01 on MacOSX and spirit 1.8.3 (from boost 1.34). The specific compiler error is: ../../src/lsystem/catalog_lsystem.cpp: In member function 'void do_appender::act(T&, const IteratorT&, const IteratorT&) const [with T = phoenix::actor<phoenix::closure_member<0, phoenix::closure<String, size_t, String> > >, IteratorT = __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >]': <snip> ../../src/lsystem/catalog_lsystem.cpp:211: error: no matching function for call to 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >::basic_string (phoenix::actor<phoenix::closure_member<0, phoenix::closure<String, size_t, String> > >&)' From the error, it appears that I need some transformation from phoenix::actor back into my closure member, which is a String (typedef for std::basic_string<char>). Any suggestions? do_appender (a simple example actor) looks like: struct do_appender { template <typename T, typename ValueT> void act(T& ref, ValueT const &val) const { ref += val; } template <typename T, typename IteratorT> void act(T& ref, IteratorT const &first, IteratorT const & last) const { String s(first, last); ref += s; } }; template <typename T> inline ref_value_actor<T, do_appender> do_append(T& lhs) { return ref_value_actor<T, do_appender>(lhs); } template <typename T, typename ValueT> inline ref_const_ref_actor<T, ValueT, do_appender> do_append(T& lhs, ValueT const& val) { return ref_const_ref_actor<T, ValueT, do_appender>(lhs,val); } and the closure and grammar (stripped slightly) look like: struct ProductionClosure : boost::spirit::closure<ProductionClosure, String, size_t, String> { member1 m_result; member2 m_count; member3 m_temporary; }; struct ParameterLSystem::ProductionGrammar : public grammar<ParameterLSystem::ProductionGrammar, ProductionClosure::context_t> { String * m_append; ProductionGrammar(String * ap) : m_append(ap) {} template <typename ScannerT> struct definition { typedef rule<ScannerT, ProductionClosure::context_t> rule_t; typedef rule<ScannerT> srule_t; srule_t r_segment; rule_t r_segments; srule_t r_leaf; rule_t r_leaves; srule_t r_push; srule_t r_pop; rule_t r_start; rule_t r_terminalLeaves; rule_t r_branch; rule_t r_top; definition(ProductionGrammar const& self) { // basics r_leaf = ch_p('L'); r_leaves = (+r_leaf)[r_leaves.m_result = construct_<String>(arg1, arg2)]; r_segment = ch_p('S'); r_segments = (+r_segment)[r_segments.m_result = construct_<String>(arg1, arg2)]; r_push = ch_p('['); r_pop = ch_p(']'); r_terminalLeaves = r_push[do_append (r_terminalLeaves.m_result)]; r_top = r_branch[self.m_result = arg1]; } rule_t const& start() const { return r_top; } }; }; }; String is a typedef for std::basic_string<char> in my namespace. When I use m_append for a "temporary", I can get things to "work", i.e., it compiles and generates the correct output but the grammar will get more complex and I don't believe I can get away without using a closure variable. The full error stack from the compiler is: ../../src/lsystem/catalog_lsystem.cpp: In member function 'void do_appender::act(T&, const IteratorT&, const IteratorT&) const [with T = phoenix::actor<phoenix::closure_member<0, phoenix::closure<String, size_t, String> > >, IteratorT = __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >]': ../../../../opensource/opt/include/boost/spirit/actor/ ref_value_actor.hpp:59: instantiated from 'void boost::spirit::ref_value_actor<T, ActionT>::operator()(const IteratorT&, const IteratorT&) const [with IteratorT = __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >, T = phoenix::actor<phoenix::closure_member<0, phoenix::closure<String, size_t, String> > >, ActionT = do_appender]' ../../../../opensource/opt/include/boost/spirit/core/scanner/ scanner.hpp:146: instantiated from 'static void boost::spirit::attributed_action_policy<boost::spirit::nil_t>::call (const ActorT&, boost::spirit::nil_t, const IteratorT&, const IteratorT&) [with ActorT = boost::spirit::ref_value_actor<phoenix::actor<phoenix::closure_member<0, phoenix::closure<String, size_t, String> > >, do_appender>, IteratorT = __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >]' ../../../../opensource/opt/include/boost/spirit/core/scanner/ scanner.hpp:161: instantiated from 'void boost::spirit::action_policy::do_action(const ActorT&, AttrT&, const IteratorT&, const IteratorT&) const [with ActorT = boost::spirit::ref_value_actor<phoenix::actor<phoenix::closure_member<0, phoenix::closure<String, size_t, String> > >, do_appender>, AttrT = boost::spirit::nil_t, IteratorT = __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >]' ../../../../opensource/opt/include/boost/spirit/core/composite/ actions.hpp:109: instantiated from 'typename boost::spirit::parser_result<boost::spirit::action<ParserT, ActionT>, ScannerT>::type boost::spirit::action<ParserT, ActionT>::parse(const ScannerT&) const [with ScannerT = boost::spirit::scanner<__gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >, boost::spirit::scanner_policies<boost::spirit::iter_policy_t, boost::spirit::match_policy, boost::spirit::action_policy> >, ParserT = boost::spirit::rule<boost::spirit::scanner<__gnu_cxx::__normal_iterator< char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >, boost::spirit::scanner_policies<boost::spirit::iter_policy_t, boost::spirit::match_policy, boost::spirit::action_policy> >, boost::spirit::nil_t, boost::spirit::nil_t>, ActionT = boost::spirit::ref_value_actor<phoenix::actor<phoenix::closure_member<0, phoenix::closure<String, size_t, String> > >, do_appender>]' ../../../../opensource/opt/include/boost/spirit/core/non_terminal/ impl/rule.ipp:233: instantiated from 'typename boost::spirit::match_result<ScannerT, ContextResultT>::type boost::spirit::impl::concrete_parser<ParserT, ScannerT, AttrT>::do_parse_virtual(const ScannerT&) const [with ParserT = boost::spirit::action<boost::spirit::rule<boost::spirit::scanner<__gnu_c xx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >, boost::spirit::scanner_policies<boost::spirit::iter_policy_t, boost::spirit::match_policy, boost::spirit::action_policy> >, boost::spirit::nil_t, boost::spirit::nil_t>, boost::spirit::ref_value_actor<phoenix::actor<phoenix::closure_member<0, phoenix::closure<String, size_t, String> > >, do_appender> >, ScannerT = boost::spirit::scanner<__gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >, boost::spirit::scanner_policies<boost::spirit::iter_policy_t, boost::spirit::match_policy, boost::spirit::action_policy> >, AttrT = String]' ../../src/lsystem/catalog_lsystem.cpp:547: instantiated from here ../../src/lsystem/catalog_lsystem.cpp:211: error: no matching function for call to 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >::basic_string (phoenix::actor<phoenix::closure_member<0, phoenix::closure<String, size_t, String> > >&)'

3 2

Serialization : Deserializing members not present in archive
by Booster Booster 04 Jan '07

04 Jan '07

Hey, I have a class with a few data members that is serializable. Note that, I already have an archive ( test.txt ). Now, I want to serialize a couple more members. I went ahead and added the new members to my serialize functions. When I read from the archive ( test.txt ) , I get an exception. This is understandable, because the archive doesn't have the new members that I'm trying to read out. My question is, is there a way to check for the existence of a member before deserializing an object from the archive ? Thanks in advance, Sandeep.

2 1

Re: [Boost-users] asio has a very confusing name - should be changed or made asynchronous
by Christopher Kohlhoff 04 Jan '07

04 Jan '07

Hi Marc, On Fri, 29 Dec 2006 11:15:12 +0100, "Marc Lehmann" <schmorp(a)schmorp.de> said: > I just saw that asio went into the boost cvs. > > I was interested because asio claims to provide an "asynchronous I/O > model", which sounds great. > > However, looking at current asio, there is nothing asynchronous, asio > is completely synchronous by API Hmmm, maybe we have different ideas about what an asynchronous I/O model looks like :) > (and on POSIX platforms): > > * the asio API is synchronous because it requires blocking calls to > io_service.run (), making it completely synchronous by API because > no I/O is done asynchronously to the program. The asio API is, not coincidentally, similar in design to the POSIX async I/O functions, as well as the Extended Sockets API (ES-API) also defined by the Open Group, and of course overlapped I/O on Windows. For example: * Asynchronous operations are initiated using a function call specific to the operation being requested: asio - basic_stream_socket::async_receive() POSIX aio - aio_read() ES-API - exs_recv() Windows - WSARecv() * The application must provide the buffer for the operation when calling the initiating function, and ensure that it remains valid (and also not attempt to access it) until the operation completes. * A blocking call is used to wait for operations to complete: asio - io_service::run() POSIX aio - aio_suspend() ES-API - exs_qdequeue() Windows - GetQueuedCompletionStatus() The main difference with asio is that, by default, it combines waiting for the operations to complete with dispatching the associated completion handler. > * on POSIX at least it calls select (or poll), which are synchronous > by nature (see > http://www.opengroup.org/onlinepubs/009695399/functions/select.html, > "select - synchronous I/O multiplexing"). Yes, the asio API can be implemented in terms of synchronous I/O demultiplexers, such as select (or epoll or kqueue). I see this as one of asio's key strengths, as it enables the API to be implemented portably. It is also intended that the API can be implemented in terms of native asynchronous I/O if available (and if the implementation actually has decent performance). This is currently the case for asio on Windows. The asio API is still asynchronous even if it is implemented in terms of a synchronous demultiplexer. All that the interface "says" is that when you initiate an asynchronous operation, the "observable behaviour" (i.e. the data copy to or from kernel space) will occur some time between the start of the initiating function until immediately before the completion handler is called. This means the observable behaviour is asynchronous with respect to the program's flow of control. > * it seems to work only on non-blocking filehandles on POSIX, either, so > file I/O is either not possible or not asynchronous. Asio doesn't do file I/O at this time (although it is planned for the future). > Is it planned to change the API into an asynchronous API and provide > asynchronous I/O later? If not, I think it might be better to change > the name into something that reflects the contents ("synchronous I/O > model sounds a bit boring, how about "network/nonlinear I/O model" or > even "standard I/O model"). > > Otherwise we would end up with a synchronous I/O model called > "asynchronous", which will likely confuse a lot of people who want a > real asynchronous I/O model (as provided by POSIX for example). > > Maybe asynchronous was confused with event-based when naming the > library? Just because I/O is not done linearly anymore does not mean > its not done in an asynchronous way, though. Of course, event-based programming and asynchronous I/O are not mutually exclusive. IMHO the asio API is both asynchronous and event-based in terms of what it provides to the library user. That asio can be implemented using synchronous mechanisms doesn't change this. Cheers, Chris

3 2

Re: [Boost-users] COM and boost::intrusive_ptr
by Nat Goodspeed 04 Jan '07

04 Jan '07

________________________________________ From: boost-users-bounces(a)lists.boost.org [mailto:boost-users-bounces@lists.boost.org] On Behalf Of Philipp Henkel Sent: Thursday, January 04, 2007 12:34 PM To: boost-users(a)lists.boost.org Subject: [Boost-users] COM and boost::intrusive_ptr 1. I need to access the address of the raw pointer (to use QueryInterface). Therefore I implemented operator& for intrusive_ptr. Like in COM this pointer-pointer will only be used for intialization purposes. My implementation relies on the intrusive_ptr's memory layout and returns reinterpret_cast<T**>(addressof(ptr)). I know, this is evil... CComPtr-like usage: boost::intrusive_ptr<IVideo> video; someObject->QueryInterface(IID_IVideo,(void**)&video); Is there a better way? How do you bring intrusive_ptr and QueryInterface together? [Nat] Sorry if this is naïve... Wouldn't it work to do something like this? IVideo* temp_video = NULL; someObject->QueryInterface(IID_IVideo, &temp_video); boost::intrusive_ptr<IVideo> video(temp_video);

2 1

boost::bind - using boost::weak_ptr
by Remigiusz �ukowski 04 Jan '07

04 Jan '07

hello, Callback mechanism defined by boost::function and by means boost::bind instead of using callback virtual class is very comfortable, but has one big shortcoming: using callback class, passing object can be stored as weak_ptr and if weak_ptr is invalid the callback can be automatically unregistered. I've tried to implement such behaviour with boost::function and boost::bind with some helper class holding weak_ptr: template<typename T> class my_wptr { boost::weak_ptr<T> m_wptr; constructors etc... }; and two helper functions: template<typename T> T* get_pointer( my_wptr &_wptr ) { boost::shared_ptr<T> sptr = _wptr.m_wptr.lock(); if( !sptr ) throw some_exception; return _wptr.get(); } and template<typename T> my_wptr<T> wptr_from( boost::weak_ptr<T> &_sptr ) { return my_wptr( _sptr ); } now I can use standard shared_ptr version: boost::function<void()> f1 = boost::bind( &class::method, some_shared_ptr ); or my version holding weak_ptr: boost::function<void()> f2 = boost::bind( &class::method, wptr_from( some_weak_ptr )); This works, but is unsafe - after get_pointer succesfully returns pointer to the object, the object is unlocked and can be deleted during class::method execution. Can anyone help me solving this problem ? regards Remigiusz Zukowski, Poland --------------------- Panorama Internetu - prognoza pogody, poczta e-mail z największym załącznikiem, SMS, wyszukiwarki: Gooru, Anonser, serwisy: randki, ogłoszenia, wakacje, program TV, Kina, muzyka, DVD, newsy, inne. http://www.panoramainternetu.pl/ (http://www.epf.pl/)

2 1

use of undefined type 'boost::STATIC_ASSERTION_FAILURE<x>
by Miguel Silvestre 04 Jan '07

04 Jan '07

Hi folks! I've just installed the serialization boost library and I'm trying to run it but I get the error in the subject. I'm trying to integrate the serialization in my project and for the begining I'm trying to follow the very simple example :-/. I've already searched the internet for this error, and I get some pages but without any answer... So here is the code: class A { private: friend class boost::serialization::access; int dumbi; float dumbf; template<class Archive> void serialize(Archive &ar, const unsigned int version) { ar & dumgf; ar & dumbi; } public: A():dumbi(12), dumbf(69.69f) { } A(int dumb1, float dumb2) : dumbi(dumb1), dumbf(dumb2) { } }; class SilvTask { private: typedef DefaultTask Parent; int dumbi; float dumbf; A testA; bool m_save, m_xml; std::string m_filename; public: SilvTask():m_save(false), dumbf(69.69f), dumbi(7), m_xml(false) { } int SilvTask::ParseArguments(const std::vector<std::string>& args) { for(uint32 i = 0; i < (uint32)args.size(); i++) { if(args[i].find("-xml")) m_xml = true; if(args[i].find("-save=") != std::string::npos) { m_filename = args[i].substr(6); m_save = true; } else if(args[i].find("-load=") != std::string::npos) { m_filename = args[i].substr(6); m_save = false; } } return FE_OK; } int SilvTask::LoadData() { if(m_save) WriteObject(); else LoadObject(); return FE_OK; } int SilvTask::WriteObject() { A aux(12, 69.69f); // create and open a character archive for output std::ofstream ofs(m_filename.c_str()); boost::archive::text_oarchive oa(ofs); //write class instance to archive oa << aux; return FE_OK; } int SilvTask::LoadObject() { A newAux; std::ifstream ifs(m_filename.c_str(), std::ios::binary); boost::archive::text_iarchive ia(ifs); // read class state from archive ia >> newAux; return FE_OK; } }; any ideias? Thanks -- Miguel Silvestre

1 0

[asio] Address already in use / reuse_address
by Maximilian Szengel 04 Jan '07

04 Jan '07

Hi list, I am having problems using asio. When I create a server (or take one of the examples from the website), start it and connect to it via telnet, then close the server (by closing all sockets, so io_service::run returns) and then want to restart the server again, I always get: "Address already in use." asio::error exception. I tried setting asio::ip::tcp::acceptor::reuse_address(true), but that didn't change anything. Any help/hint would be appreciated. Greetings, Max

3 2

mpl::inherit_linearly question
by Ovanes Markarian 04 Jan '07

04 Jan '07

Hi! I am trying to create a static visitor using metapgramming. This approach worked fine in some test code, but now I face some problems. Let me first show some example: I've define an item_visitor template class: template <class Pair> //mpl::pair obtained from map sequence struct item_visitor { public: typedef typename Pair::second value_type; virtual void visit(value_type const& t) { assert(0 && "This function must be overriden in the concrete handler class!"); } }; template<class Seq> struct base_sequence_visitor : public boost::mpl::inherit_linearly < Seq , boost::mpl::inherit<boost::mpl::_1, item_visitor<boost::mpl::_2> > >::type {}; This example works fine and I can dispatch my type. Now I have some additional type, which provides a view to my structure. And I would like my visit to implemented as: virtual void visit(GenericView<Pair::second> const& t) { ... } In such a case I have to introduce a second parameter to the item_visitor template: template<class Pair, template<class> SomeView> struct item_visitor { ... }; Therefore the base_sequence_visitor must be updated as well to forward the View template: template<class Seq, template<class> SomeView> struct base_sequence_visitor : public boost::mpl::inherit_linearly < Seq , boost::mpl::inherit<boost::mpl::_1, item_visitor<boost::mpl::_2, SomeView> > >::type {}; Using this construct I get an error, that mpl::arg<2> does not have a type second. That means that the placeholder _2 does not get expanded. So I tried to "code around" and used the following trick: template<class> calss SomeView; template<class Pair> struct some_visitor : item_visitor<Pair, SomeView> {}; Then I added to the base_sequence_visitor template an additional argument, which specifies an item visitor class to be used: template<class Seq, template<class> ItemVisitor> struct base_sequence_visitor : public boost::mpl::inherit_linearly < Seq , boost::mpl::inherit<boost::mpl::_1, ItemVisitor<boost::mpl::_2> > >::type {}; And it compiles fine! But when I try to cast the base_sequence_visitor to some complete item_visitor type, which is really in the sequence I receive a compiler error, that cannot convert from 'base_sequence_visitor<Seq,ItemVisitor>' to 'ClassWhereSimpleVisitorIsDefined::simple_visitor<PairType> &' Do I miss something? With Kind Regards, Ovanes Markarian

3 4

[graph] leda_graph.hpp: edge property maps
by Jens Müller 04 Jan '07

04 Jan '07

leda_graph.hpp has an adapter for leda::node_array's as property maps. Could the same code (replacing node by edge, where appropriate) be used to make an adapter for leda::edge_array's? Well, I'll try this out right now ...

1 2