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

Error :Boost 1.48.0 with latest IBM compiler
by devika R S 24 Jul '12

24 Jul '12

Hi All, This post is regarding the issue we saw on IBM compiler using BOOST 1.48 version. Here is the sample code . *********************************Example Code************************************* #include <boost/config/warning_disable.hpp> #include <boost/spirit/include/qi.hpp> #include <boost/spirit/include/phoenix_operator.hpp> #include <boost/spirit/home/phoenix/statement/if.hpp> #include <boost/spirit/home/phoenix/bind/bind_function.hpp> #include <… [View More]iostream> #include <string> namespace client { namespace qi = boost::spirit::qi; namespace ascii = boost::spirit::ascii; namespace phx = boost::phoenix; struct vars_ : qi::symbols<char, double> { vars_() { add("ans" , 0); } } vars; template <typename Iterator> struct parser : qi::grammar<Iterator, double()> { parser() : parser::base_type(function) { using qi::eps; using qi::lit; using qi::_val; using qi::_1; using ascii::char_; using qi::double_; using qi::string; using qi::lexeme; using boost::phoenix::if_; using qi::alpha; using qi::alnum; MAX = lexeme[string("max") | string("MAX")]; //define max symbol MIN = lexeme[string("min") | string("MIN")]; //define min symbol D = lexeme[string("d") | string("D")]; //define distance symbol function = expression [_val = _1] | declaration | assignment | ( MAX >> "(" >> function [_val = _1] >> +(',' >> function [if_(_1 > _val)[_val = _1]]) >> ')') // call : max(function,...) | ( MIN >> "(" >> function [_val = _1] >> +(',' >> function [if_(_1 < _val)[_val = _1]]) >> ')') // call : min(function,...) | ( D >> "(" >> (function >> ',' >> function) >> ')'); // call : d(point1,point2) not implemented yet expression = term [_val = _1] >> *( ('+' >> term [_val += _1]) | ('-' >> term [_val -= _1])); term = factor [_val = _1] >> *( ('*' >> factor [_val *= _1]) | ('/' >> factor [_val /= _1])); factor = double_ [_val = _1] | (vars [_val += _1] ) | '(' >> expression [_val = _1] >> ')' | ('-' >> factor [_val = -_1]) | ('+' >> factor [_val = _1]) | declaration; ; assignment = vars >> '=' >> function; var_decl = lexeme [ qi::raw [ ( alpha >> *( alnum | '_' ) ) - vars ] ] //[ phx::bind(vars.add, _1) ] ; declaration = "var " >> var_decl >> *( ',' >> var_decl ); } qi::rule<Iterator, double()> MAX, MIN, D,expression, term, factor, function, assignment, var_decl, declaration; }; } int main() { typedef std::string::const_iterator iterator_type; typedef client::parser<iterator_type> parser; parser _parser; // Our grammar std::string str; double result; while (std::getline(std::cin, str)) { if (str.empty() || str[0] == 'q' || str[0] == 'Q') break; std::string::const_iterator iter = str.begin(); std::string::const_iterator end = str.end(); bool r = parse(iter, end, _parser, result); if (r && iter == end) { std::cout << "Parsing succeeded\n"; std::cout << "result = " << result << std::endl; } else { std::string rest(iter, end); std::cout << "Parsing failed\n"; } } return 0; } *********************************END************************************************** When we compile this code on IBM with the compiler : IBM XL C/C++ for AIX, V11.1 (5724-X13).Version: 11.01.0000.0009 we end up with below error: xlC -I/usr/include/common/boost -o test2.o -O -c -qnoansialias -qnoro -qchars=signed -q64 -qrtti=all test2.cpp "/usr/include/common/boost/boost/integer_traits.hpp", line 83.56: 1540-0724 (W) The non-type template argument "-1" of type "T" has wrapped. "/usr/include/common/boost/boost/spirit/home/support/terminal.hpp", line 231.13: 1540-0407 (S) The base class "to_nonlazy_arg<const char [4]>" contains a circular reference back to "to_nonlazy_arg<const char [4]>". "/usr/include/boost/boost/spirit/home/support/terminal.hpp", line 288.46: 1540-0700 (I) The previous message was produced while processing "struct boost_1_48_0::spirit::detail::to_nonlazy_arg<const char [4]>". "/usr/include/common/boost/boost/spirit/home/support/terminal.hpp", line 281.16: 1540-0700 (I) The previous message was produced while processing "struct boost_1_48_0::spirit::terminal<struct boost_1_48_0::spirit::tag::char_code<boost_1_48_0::spirit::tag::string,boost_1_48_0::spirit::char_encoding::standard> >::result_helper<0,const char [4],boost_1_48_0::spirit::unused_type,boost_1_48_0::spirit::unused_type>". "/usr/include/common/boost/boost/spirit/home/support/terminal.hpp", line 316.16: 1540-0700 (I) The previous message was produced while processing "struct boost_1_48_0::spirit::terminal<struct boost_1_48_0::spirit::tag::char_code<boost_1_48_0::spirit::tag::string,boost_1_48_0::spirit::char_encoding::standard> >::result<const char [4],boost_1_48_0::spirit::unused_type,boost_1_48_0::spirit::unused_type>". "/usr/include/common/boost/boost/spirit/home/support/terminal.hpp", line 248.12: 1540-0700 (I) The previous message was produced while processing "struct boost_1_48_0::spirit::terminal<boost_1_48_0::spirit::tag::char_code<boost_1_48_0::spirit::tag::string,boost_1_48_0::spirit::char_encoding::standard> >". "/usr/include/common/boost/boost/spirit/home/support/common_terminals.hpp", line 230.1: 1540-0700 (I) The previous message was produced while processing "boost_1_48_0::spirit::standard::string". But this code works absolutely fine on g++ Linux. Is this is a known bug on IBM ?Is any patch available ? Thanks in advance, Abc [View Less]

1 0

Problems with boost::this_thread::sleep(boost::posix_time::milliseconds(100)) on 64 bit platform.
by Serg V. Gulko 23 Jul '12

23 Jul '12

Hello! I was trying to recompile code which was working perfectly on CentOS 6 32 bit under same version of CentOS but for 64bit. boost version is 1.49.0. Problem is that this_thread::sleep return immediately on 64 bit machine... Only increasing sleep time to 3000 i was able to see real sleep. I saw that many people have same problem but is there a way to easily resolve it? Serg

3 2

[BGL] Encountering "bad lexical cast" exception when reading a class from graphviz file
by Nicholas Mario Wardhana 23 Jul '12

23 Jul '12

Hi all, I am trying to read a graphviz file into my graph implementation. The minimum working code as well as the graphviz file are at the end of this e-mail. The node of the graph is the Vertex struct, which contains a point object (Point p). For Point class, I overload two operators, >> and <<, and operator << was previously used to generate the graphviz file. The operator overloads work well with std::cin and std::cout, but with the code below, I receive an exception: … [View More]bad lexical cast: source type value could not be interpreted as target . The culprit might be in the << overload. In particular, when reading from a file, the value of iToBool1 is true, whereas iToBool2 is false. That is to say, the variable i might change when inserting the stream data to the point. This does not happen when reading from std::cin, as both variables are true. I convert the i variable, originally an istream, to bool because when the program returns to the calling function, which is lexical_stream_limited_src::shr_using_base_class on line 1616 in lexical_cast.hpp, this functions uses the return value of << operator in a boolean comparison. The value of iToBool2 being false eventually leads to calling BOOST_LCAST_THROW_BAD_CAST on line 1975. I wonder if somebody can tell me what is wrong with my operator overload? I use Boost 1.50 and Visual Studio 2008 on Windows 7. Thanks! Best regards, Nicholas //--------------------Graphviz-------------------- graph G { 1 [Point="1 2 3"]; } //----------------------code---------------------- #include <boost/graph/adjacency_list.hpp> #include <boost/property_map/dynamic_property_map.hpp> #include <boost/graph/graphviz.hpp> #include <iostream> #include <fstream> #include <string> struct Point { float x; float y; float z; inline friend std::istream& operator >> ( std::istream& i, Point& p ) { bool iToBool1 = i; i >> p.x >> p.y >> p.z; bool iToBool2 = i; return i; } inline friend std::ostream& operator << ( std::ostream& o, const Point& p ) { o << p.x << " " << p.y << " " << p.z; return o; } }; struct Vertex { int ID; Point p; }; struct Edge { int ID; }; typedef boost::adjacency_list< boost::listS, boost::vecS, boost::undirectedS, Vertex, // bundled data Edge, // bundled data boost::no_property, // not needed boost::listS> Graph; int main() { // Part 1: input via std::cin Point p; std::cin >> p; Graph graph; // Part 2: input from graphviz boost::dynamic_properties dynamicProperties; dynamicProperties.property("NodeID", boost::get(&Vertex::ID, graph)); dynamicProperties.property("Point", boost::get(&Vertex::p, graph)); dynamicProperties.property("EdgeID", boost::get(&Edge::ID, graph)); std::ifstream file("graph.txt"); try { boost::read_graphviz(file, graph, dynamicProperties, "NodeID"); } catch (std::exception& e) { std::cout << e.what() << std::endl; } return 0; } [View Less]

2 4

state machine frequence detecting
by Kraus Philipp 23 Jul '12

23 Jul '12

Hello, I need an idea for detecting frequencies. I have got an audio signal and I would check if a sequence of frequences are in the signal eg: I have got this frequencies: 100Hz, 600Hz, 800Hz, so I would create a statemachine that accepts this sequence of frequencies like frequence statemachin st; for each audio sample if signal has st.getFrequence then st.next else st.reset if st.final then accept Frequences and the order of the frequences are stored … [View More]

2 1

Extracting "friendly" information from boost::exception
by Andreas M. Iwanowski 22 Jul '12

22 Jul '12

Dear boost experts. We are using boost::exception in a project of ours, and are trying to extract some information from an exception to display to the user. For example, diagnostic_information(e) returns this: d:\projects\<project>\ClassName.cpp(376): Throw in function void __thiscall ClassName::CInetExceptionHandler<struct ClassName::BadLoginException>(class CInternetException *) const Dynamic exception type: class boost::exception_detail::clone_impl<struct ClassName::… [View More]

2 1

filesystem - test failures
by Robert Ramey 22 Jul '12

22 Jul '12

The boost serialization library tests use boost.filesystem. A number of test scenarios in the serialization library tests suite are really manifestations of failures in the boost filesystem library. a) msvc- 9.0~wm5~stlport5.2 - this combination fails at some level for lack of a file "io.h". b) does filesystem really require RTTI? at least a subset (and maybe more) of the serialization library tests should function in the absense of RTTI but now they all fail since all the tests use … [View More]

1 0

code review
by Littlefield, Tyler 22 Jul '12

22 Jul '12

Hello all: I understand this may be a bit unusual, but any help/info would really be appreciated. Basically, here's what the problem is. I am using boost::asio to write a client and server for a game setup I want to work on. They're not communicating with each other, but more importantly, before I get way to far with this, since I am just learning boost::asio and everything else, I'd like to see if there is something I could be doing differently/better to make everything smoother. All the … [View More]

1 0

[Program Options] Input information as std::string
by Nicholas Yue 22 Jul '12

22 Jul '12

Hi, I have a situation where I would like to parse the command line options not as (int argc, char **argv) template<typename charT> basic_parsed_options< charT > parse_command_line(int argc, const charT *const argv, const options_description &, int style = 0, function1< std::pair< std::string, std::string >, const std::string & > ext = ext_parser()); but as a std::string. … [View More]

3 2

boost::unordered_map and exceptions disabled
by Marcello Maggioni 22 Jul '12

22 Jul '12

Hello, I'm a user of boost::unordered_map and I always used this container with exceptions disabled (because I never use them and don't want them enabled if possible). I never had problems with that, but now with boost 1.50 and GCC 4.7.1 I get this error while compiling code using unordered_map: In file included from /usr/include/boost/unordered/unordered_map.hpp:17:0, from /usr/include/boost/unordered_map.hpp:16, from /home/hades/Bitral/include/CodeRegion.h:… [View More]23, from /home/hades/Bitral/src/BitralContext.cpp:20: /usr/include/boost/unordered/detail/allocator_helpers.hpp: In instantiation of 'void boost::unordered::detail::construct_node(Alloc&, T*, const Args&) [with Alloc = std::allocator<boost::unordered::detail::ptr_node<std::pair<const Bitral::ConstantMemoryAddress, Bitral::CodeRegion*> > >; T = boost::unordered::detail::ptr_node<std::pair<const Bitral::ConstantMemoryAddress, Bitral::CodeRegion*> >; Args = boost::unordered::detail::emplace_args3<boost::unordered::piecewise_construct_t, boost::tuples::tuple<Bitral::ConstantMemoryAddress, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type>, boost::tuples::tuple<> >]': /usr/include/boost/unordered/detail/buckets.hpp:75:13: required from 'void boost::unordered::detail::node_constructor<NodeAlloc>::construct_value(const Args&) [with Args = boost::unordered::detail::emplace_args3<boost::unordered::piecewise_construct_t, boost::tuples::tuple<Bitral::ConstantMemoryAddress, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type>, boost::tuples::tuple<> >; NodeAlloc = std::allocator<boost::unordered::detail::ptr_node<std::pair<const Bitral::ConstantMemoryAddress, Bitral::CodeRegion*> > >]' /usr/include/boost/unordered/detail/unique.hpp:386:13: required from 'boost::unordered::detail::table_impl<Types>::value_type& boost::unordered::detail::table_impl<Types>::operator[](const key_type&) [with Types = boost::unordered::detail::map<std::allocator<std::pair<const Bitral::ConstantMemoryAddress, Bitral::CodeRegion*> >, Bitral::ConstantMemoryAddress, Bitral::CodeRegion*, boost::hash<Bitral::ConstantMemoryAddress>, std::equal_to<Bitral::ConstantMemoryAddress> >; boost::unordered::detail::table_impl<Types>::value_type = std::pair<const Bitral::ConstantMemoryAddress, Bitral::CodeRegion*>; boost::unordered::detail::table_impl<Types>::key_type = Bitral::ConstantMemoryAddress]' /usr/include/boost/unordered/unordered_map.hpp:1196:26: required from 'boost::unordered::unordered_map<K, T, H, P, A>::mapped_type& boost::unordered::unordered_map<K, T, H, P, A>::operator[](const key_type&) [with K = Bitral::ConstantMemoryAddress; T = Bitral::CodeRegion*; H = boost::hash<Bitral::ConstantMemoryAddress>; P = std::equal_to<Bitral::ConstantMemoryAddress>; A = std::allocator<std::pair<const Bitral::ConstantMemoryAddress, Bitral::CodeRegion*> >; boost::unordered::unordered_map<K, T, H, P, A>::mapped_type = Bitral::CodeRegion*; boost::unordered::unordered_map<K, T, H, P, A>::key_type = Bitral::ConstantMemoryAddress]' /home/hades/Bitral/src/BitralContext.cpp:30:31: required from here /usr/include/boost/unordered/detail/allocator_helpers.hpp:643:11: error: exception handling disabled, use -fexceptions to enable The strange thing is that compiling the code with CLANG 3.1 and exceptions explicitly disabled works fine. There is a way to make it work with exceptions disabled and G++? Thanks Marcello [View Less]

2 1

[type_traits] defining my own trait
by Brian Budge 21 Jul '12

21 Jul '12

Hi all - I am hoping to define my own type trait is_memcpyable. I'm trying to start off simple: template <typename T> struct is_memcpyable { static const bool value = boost::has_trivial_assign<T>::value; }; Then when I encounter types in my code that are safe to memcpy, but don't have a trivial assignment operator I can specialize the trait. I'm having trouble with inheritance and composition. I'm hoping someone can help. Here's a complete code sample: /***START OF … [View More]SAMPLE***/ #include <Eigen/Dense> #include <iostream> template <typename T> struct is_memcpyable { static const bool value = boost::has_trivial_assign<T>::value; }; namespace boost { template<> struct has_trivial_assign<Eigen::Vector3f> : public true_type {}; } struct foo : public Eigen::Vector3f { foo() {} }; struct bar { bar(int i) : m_vec(float(i), float(i), float(i)) {} Eigen::Vector3f m_vec; }; int main(int argc, char **args) { std::cerr << "memcpyable int: " << is_memcpyable<int>::value << std::endl; std::cerr << "memcpyable v3f: " << is_memcpyable<Eigen::Vector3f>::value << std::endl; std::cerr << "memcpyable bar: " << is_memcpyable<bar>::value << std::endl; std::cerr << "memcpyable foo: " << is_memcpyable<foo>::value << std::endl; std::cerr << "trivial assign int: " << boost::has_trivial_assign<int>::value << std::endl; std::cerr << "trivial assign v3f: " << boost::has_trivial_assign<Eigen::Vector3f>::value << std::endl; std::cerr << "trivial assign bar: " << boost::has_trivial_assign<bar>::value << std::endl; std::cerr << "trivial assign foo: " << boost::has_trivial_assign<foo>::value << std::endl; return 0; } /***END OF SAMPLE***/ The Eigen library is set up to do nifty expression template goodness all over the place, which means that they implement operator = for the types in the library. However, once a value is assigned, the storage is fixed (at least for the Dense matrix types). The data layout is fixed, and internal storage is a small array of builtin types. What I would like to happen is that all 8 print statements should be true; however, the ones for bar and foo are false. I can explicitly set their type traits, but this quickly gets out of hand. I guess the real question is this: is there a way to define is_memcpyable so that the value is true if a class does not define operator=, and all of it's members or inherited types are also memcpyable? Thanks for any help. Brian [View Less]

3 4

Missing libboost_thread-vc100-mt-s-1_49.lib
by VimalMathew＠Eaton.com 20 Jul '12

20 Jul '12

Hi, I'm trying to build a project using nmake. When I run nmake I get this error message: " LINK : fatal error LNK1104: cannot open file 'libboost_thread-vc100-mt-s-1_49.lib " Could someone tell me what I'm missing please? Thanks, Vimal

1 0

How to force a compile failure if a template parameter isn't floating-point
by Paul A. Bristow 20 Jul '12

20 Jul '12

I have some functions that I want to ensure (with a compile failure - because it means a logical mistake) that they are not instantiated if the template parameter is not floating point type. In effect, #error Type Not floating point! template <typename FPT> std::string f(FPT v) { ... } At present I have added a run-time check, but doesn't prevent compilation (and instantiation). if (boost::is_floating_point<FPT>::value; == false) { assert fail or something and/or … [View More]

5 7

[ASIO] Patch to support ATM sockets
by Casimiro, Daniel C CIV NUWC NWPT 20 Jul '12

20 Jul '12

Hi, These classes and examples add basic ATM support to ASIO. It works with MS visual studio 2010 (Windows XP) and gcc 4.1.2 (Linux CentOS 5.8), but it isn't always pretty. I only implemented and tested PVC's. ~Dan --------------------------- // stdafx.h : include file for standard system include files, // or project specific include files that are used frequently, but // are changed infrequently // #ifndef BOOST_STDAFX_HEAD #define BOOST_STDAFX_HEAD #ifdef _WIN32 #include "targetver.h" #… [View More]define WIN32_LEAN_AND_MEAN // Exclude rarely-used stuff from Windows headers #endif #ifdef HAVE_ASIO_ATM // I forward declare my version of boost::asio::detail::socket_ops::bind so that // gcc 4.1.2 picks it up and uses it. // Otherwise, gcc doesn't consider my version; I'm not sure why. #include <boost/variant/variant_fwd.hpp> namespace boost { namespace system { class error_code; } } namespace boost { namespace asio { namespace atm { namespace detail { struct atmpvc_endpoint_type; struct atmsvc_endpoint_type; } } } } namespace boost { namespace asio { namespace detail { namespace socket_ops { int bind(int s, const boost::variant<boost::asio::atm::detail::atmpvc_endpoint_type, boost::asio::atm::detail::atmsvc_endpoint_type>* addr, size_t addrlen, boost::system::error_code& ec); } } } } #endif #include <boost/asio.hpp> #endif // BOOST_STDAFX_HEAD // Example echo server with ATM sockets // async_atm_echo_server.cpp : Defines the entry point for the console application. // #include "stdafx.h" #include <cstdlib> #include <iostream> #include <string> #include <boost/bind.hpp> #include <boost/asio.hpp> #include "boost/asio/atm/aal.hpp" using namespace boost::asio::atm; class server { public: server(boost::asio::io_service& io_service, const std::string &a) : io_service_(io_service) , socket_(io_service, aal::endpoint(address::from_string(a), qos::ubr_settings(1024u))) , data_() { socket_.async_receive( boost::asio::buffer(data_, max_length), boost::bind(&server::handle_receive_from, this, boost::asio::placeholders::error, boost::asio::placeholders::bytes_transferred)); } void handle_receive_from(const boost::system::error_code& error, size_t bytes_recvd) { if (!error && bytes_recvd > 0) { socket_.async_send( boost::asio::buffer(data_, bytes_recvd), boost::bind(&server::handle_send_to, this, boost::asio::placeholders::error, boost::asio::placeholders::bytes_transferred)); } else { socket_.async_receive( boost::asio::buffer(data_, max_length), boost::bind(&server::handle_receive_from, this, boost::asio::placeholders::error, boost::asio::placeholders::bytes_transferred)); } } void handle_send_to(const boost::system::error_code& /*error*/, size_t /*bytes_sent*/) { socket_.async_receive( boost::asio::buffer(data_, max_length), boost::bind(&server::handle_receive_from, this, boost::asio::placeholders::error, boost::asio::placeholders::bytes_transferred)); } private: boost::asio::io_service& io_service_; aal::socket socket_; enum { max_length = 1024 }; char data_[max_length]; }; int main(int argc, char** argv) { try { if (argc != 2) { std::cerr << "Usage: async_atm_echo_server <address>\n"; return 1; } boost::asio::io_service io_service; server s(io_service, argv[1]); io_service.run(); } catch (const std::exception& e) { std::cerr << "Exception: " << e.what() << "\n"; } return 0; } // Example echo client with ATM sockets // blocking_atm_echo_client.cpp : Defines the entry point for the console application. // #include "stdafx.h" #include <cstdlib> #include <cstring> #include <iostream> #include <boost/asio.hpp> #include "boost/asio/atm/aal.hpp" using namespace boost::asio::atm; enum { max_length = 1024 }; int main(int argc, char** argv) { try { if (argc != 2) { std::cerr << "Usage: blocking_atm_echo_client <address>\n"; return 1; } boost::asio::io_service io_service; aal::socket s(io_service, aal::endpoint(address_pvc::from_string(argv[1]), qos::ubr_settings(1024u))); using namespace std; // for strlen std::cout << "Enter message: "; char request[max_length]; std::cin.getline(request, max_length); size_t request_length = strlen(request); s.send(boost::asio::buffer(request, request_length)); char reply[max_length]; size_t reply_length = s.receive(boost::asio::buffer(reply, max_length)); std::cout << "Reply is: "; std::cout.write(reply, reply_length); std::cout << "\n"; } catch (const std::exception& e) { std::cerr << "Exception: " << e.what() << "\n"; } return 0; } /// \file boost/asio/atm/aal.hpp /// UNCLASSIFIED /// \brief Asynchronous Transfer Mode support for Boost ASIO #ifndef BOOST_ASIO_ATM_AAL_HEAD #define BOOST_ASIO_ATM_AAL_HEAD #ifdef HAVE_ASIO_ATM #include <boost/asio.hpp> #include <boost/variant.hpp> #include "basic_endpoint.hpp" namespace boost { namespace asio { using boost::asio::basic_raw_socket; namespace atm { /// \brief ATM Adaptation Layer template <class Implementation> class basic_aal { public: typedef Implementation implementation_type; /// The type of a ATM endpoint. typedef basic_endpoint<basic_aal> endpoint; static basic_aal aal5_pvc() { return basic_aal(implementation_type::aal5_protocol(), implementation_type::pvc_family()); } static basic_aal aal5_svc() { return basic_aal(implementation_type::aal5_protocol(), implementation_type::svc_family()); } /// Obtain an identifier for the type of the protocol. int type() const { // windows only support SOCK_RAW // The Linux examples use SOCK_DGRAM; is there a difference at application // level for AAL5 sockets? Can Linux use SOCK_RAW? return implementation_type::socket_type(); } /// Obtain an identifier for the protocol. int protocol() const { return protocol_; } /// Obtain an identifier for the protocol family. int family() const { return family_; } /// The ATM/AAL socket type. typedef basic_raw_socket<basic_aal> socket; /// The ATM/AAL resolver type. //typedef basic_resolver<atm> resolver; /// Compare two protocols for equality. friend bool operator==(const basic_aal& p1, const basic_aal& p2) { return p1.protocol_ == p2.protocol_ && p1.family_ == p2.family_ ; } /// Compare two protocols for inequality. friend bool operator!=(const basic_aal& p1, const basic_aal& p2) { return p1.protocol_ != p2.protocol_ || p1.family_ != p2.family_ ; } private: // Construct with a specific protocol. explicit basic_aal(const int protocol, const int family) : protocol_(protocol) , family_(family) { } int protocol_; int family_; }; // class basic_aal #if defined BOOST_WINDOWS || defined(__CYGWIN__) struct windows_atm { static int aal5_protocol() { return ATMPROTO_AAL5; } static int socket_type() { return SOCK_RAW; } static int pvc_family() { return AF_ATM; } static int svc_family() { return AF_ATM; } /// is this legal? //typedef template <class Protocol> basic_raw_socket socket_template; }; // windows_atm typedef basic_aal<windows_atm> aal; #else struct bsd_atm { static int aal5_protocol() { return 0; } static int socket_type() { return SOCK_RAW; } static int pvc_family() { return AF_ATMPVC; } static int svc_family() { return AF_ATMSVC; } /// is this legal? //typedef template <class Protocol> basic_raw_socket socket_template; }; // bsd_atm typedef basic_aal<bsd_atm> aal; #endif } // namespace atm } // namespace asio } // namespace boost #endif // HAVE_ASIO_ATM #endif // BOOST_ASIO_ATM_AAL_HEAD /// \file boost/asio/atm/address.hpp /// UNCLASSIFIED /// \brief Asynchronous Transfer Mode address for Boost ASIO #ifndef BOOST_ASIO_ATM_ADDRESS_HEAD #define BOOST_ASIO_ATM_ADDRESS_HEAD #include <string> #include <boost/asio.hpp> #include "address_pvc.hpp" #include "address_svc.hpp" namespace boost { namespace asio { namespace atm { using boost::system::error_code; class address { public: address() : type_(pvc) , pvc_address_() , svc_address_() { } address(const address_pvc &pvc_address) : type_(pvc) , pvc_address_(pvc_address) , svc_address_() { } address(const address_svc &svc_address) : type_(svc) , pvc_address_() , svc_address_(svc_address) { } address(const address &other) : type_(other.type_) , pvc_address_(other.pvc_address_) , svc_address_(other.svc_address_) { } bool is_pvc() const { return type_ == pvc; } bool is_svc() const { return type_ == svc; } const address_pvc& to_pvc() const { return pvc_address_; } const address_svc& to_svc() const { return svc_address_; } std::string to_string() const { if (is_pvc()) { return pvc_address_.to_string(); } return svc_address_.to_string(); } std::string to_string(error_code &error) const { if (is_pvc()) { return pvc_address_.to_string(error); } return svc_address_.to_string(error); } static address from_string(const char * str) { error_code error; const address addr = from_string(str, error); boost::asio::detail::throw_error(error); return addr; } static address from_string(const char * str, error_code &error) { const address_pvc pvc_address = address_pvc::from_string(str, error); if (!error) { return address(pvc_address); } const address_svc svc_address = address_svc::from_string(str, error); if (!error) { return address(svc_address); } return address(); } static address from_string(const std::string &str) { return from_string(str.c_str()); } static address from_string(const std::string &str, error_code &error) { return from_string(str.c_str(), error); } /// Compare two addresses for equality. friend bool operator==(const address& a1, const address& a2) { if (a1.type_ != a2.type_) { return false; } if (a1.type_ == pvc) { return a1.pvc_address_ == a2.pvc_address_; } return a1.svc_address_ == a2.svc_address_; } /// Compare two addresses for inequality. friend bool operator!=(const address& a1, const address& a2) { return !(a1 == a2); } /// Compare addresses for ordering. friend bool operator<(const address& a1, const address& a2) { if (a1.type_ < a2.type_) { return true; } if (a1.type_ > a2.type_) { return false; } if (a1.type_ == pvc) { return a1.pvc_address_ < a2.pvc_address_; } return a1.svc_address_ < a2.svc_address_; } /// Compare addresses for ordering. friend bool operator>(const address& a1, const address& a2) { return a2 < a1; } /// Compare addresses for ordering. friend bool operator<=(const address& a1, const address& a2) { return !(a2 < a1); } /// Compare addresses for ordering. friend bool operator>=(const address& a1, const address& a2) { return !(a1 < a2); } private: enum { svc, pvc } type_; address_pvc pvc_address_; address_svc svc_address_; }; // class address #if !defined(BOOST_NO_IOSTREAM) /// Output an address as a string. /** * Used to output a human-readable string for a specified address. * * @param os The output stream to which the string will be written. * * @param addr The address to be written. * * @return The output stream. * * @relates boost::asio::atm::address_pvc */ template <typename Elem, typename Traits> std::basic_ostream<Elem, Traits>& operator<<( std::basic_ostream<Elem, Traits>& os, const address& addr); #endif // !defined(BOOST_NO_IOSTREAM) } // namespace atm } // namespace asio } // namespace boost #endif // BOOST_ASIO_ATM_ADDRESS_HEAD /// \file boost/asio/atm/address_pvc.hpp /// UNCLASSIFIED /// \brief Asynchronous Transfer Mode PVC address for Boost ASIO #ifndef BOOST_ASIO_ATM_ADDRESS_PVC_HEAD #define BOOST_ASIO_ATM_ADDRESS_PVC_HEAD #include <string> #include <vector> #include <sstream> #include <boost/asio.hpp> #include <boost/algorithm/string.hpp> #include "detail/socket_types.hpp" #include "detail/socket_ops.hpp" namespace boost { namespace asio { namespace atm { using boost::system::error_code; class address_pvc { public: address_pvc() : addr_() { detail::socket_ops::initialize(addr_); } address_pvc(const address_pvc &other) : addr_(other.addr_) { } address_pvc(const detail::atmpvc_addr_type &a) : addr_(a) { } address_pvc(const unsigned long vpi, const unsigned long vci) : addr_() { detail::socket_ops::initialize(addr_); set_vpi(vpi); set_vci(vci); } unsigned long itf() const { return detail::socket_ops::itf(addr_); } void set_itf(const unsigned long i) { return detail::socket_ops::set_itf(i, addr_); } unsigned long vpi() const { return detail::socket_ops::vpi(addr_); } void set_vpi(const unsigned long v) { return detail::socket_ops::set_vpi(v, addr_); } unsigned long vci() const { return detail::socket_ops::vci(addr_); } void set_vci(const unsigned long v) { return detail::socket_ops::set_vci(v, addr_); } const detail::atmpvc_addr_type* data() const { return &addr_; } std::string to_string() const { error_code error; const std::string str = to_string(error); boost::asio::detail::throw_error(error); return str; } std::string to_string(error_code &error) const { std::ostringstream strm; strm << itf() << "." << vpi() << "." << vci(); return strm.str(); } static address_pvc from_string(const char *str) { error_code error; const address_pvc addr = from_string(str, error); boost::asio::detail::throw_error(error); return addr; } static address_pvc from_string(const char *str, error_code &error) { return from_string(std::string(str), error); } static address_pvc from_string(const std::string &str) { return from_string(str.c_str()); } static address_pvc from_string(const std::string &str, error_code &error) { typedef std::vector<std::string> container; address_pvc addr; container tokens; boost::split(tokens, str, boost::is_any_of(".")); if (tokens.empty()) { tokens.push_back(str); } container::const_reverse_iterator i = tokens.rbegin(); // Read the VCI first std::istringstream vci_strm(*i); unsigned long vci; if (!(vci_strm >> vci)) { error = boost::asio::error::invalid_argument; return addr; } addr.set_vci(vci); advance(i, 1); if (i == tokens.rend()) { return addr; } // Read the VPI std::istringstream vpi_strm(*i); unsigned long vpi; if (!(vpi_strm >> vpi)) { error = boost::asio::error::invalid_argument; return addr; } addr.set_vpi(vpi); advance(i, 1); if (i == tokens.rend()) { return addr; } // Read the ITF std::istringstream itf_strm(*i); unsigned long itf; if (!(itf_strm >> itf)) { error = boost::asio::error::invalid_argument; return addr; } addr.set_itf(itf); advance(i, 1); if (i != tokens.rend()) { error = boost::asio::error::invalid_argument; } return addr; } /// Compare two addresses for equality. friend bool operator==(const address_pvc& a1, const address_pvc& a2) { return a1.itf() == a2.itf() && a1.vpi() == a2.vpi() && a2.vci() == a2.vci() ; } /// Compare two address_pvces for inequality. friend bool operator!=(const address_pvc& a1, const address_pvc& a2) { return !(a1 == a2); } /// Compare address_pvces for ordering. friend bool operator<(const address_pvc& a1, const address_pvc& a2) { if (a1.itf() < a2.itf()) { return true; } if (a1.itf() > a2.itf()) { return false; } if (a1.vpi() < a2.vpi()) { return true; } if (a1.vpi() > a2.vpi()) { return false; } return a1.vci() < a2.vci(); } /// Compare address_pvces for ordering. friend bool operator>(const address_pvc& a1, const address_pvc& a2) { return a2 < a1; } /// Compare address_pvces for ordering. friend bool operator<=(const address_pvc& a1, const address_pvc& a2) { return !(a2 < a1); } /// Compare address_pvces for ordering. friend bool operator>=(const address_pvc& a1, const address_pvc& a2) { return !(a1 < a2); } private: detail::atmpvc_addr_type addr_; }; // class address_pvc #if !defined(BOOST_NO_IOSTREAM) /// Output an address as a string. /** * Used to output a human-readable string for a specified address. * * @param os The output stream to which the string will be written. * * @param addr The address to be written. * * @return The output stream. * * @relates boost::asio::atm::address_pvc */ template <typename Elem, typename Traits> std::basic_ostream<Elem, Traits>& operator<<( std::basic_ostream<Elem, Traits>& os, const address_pvc& addr); #endif // !defined(BOOST_NO_IOSTREAM) } // namespace atm } // namespace asio } // namespace boost #endif // BOOST_ASIO_ATM_ADDRESS_PVC_HEAD /// \file boost/asio/atm/address_svc.hpp /// UNCLASSIFIED /// \brief Asynchronous Transfer Mode SVC address for Boost ASIO #ifndef BOOST_ASIO_ATM_ADDRESS_SVC_HEAD #define BOOST_ASIO_ATM_ADDRESS_SVC_HEAD #include <string> #include <boost/asio.hpp> #include "detail/socket_types.hpp" namespace boost { namespace asio { namespace atm { using boost::system::error_code; class address_svc { public: address_svc() : addr_() { } address_svc(const detail::atmsvc_addr_type& a) : addr_(a) { } address_svc(const address_svc &other) : addr_(other.addr_) { } const detail::atmsvc_addr_type* data() const { return &addr_; } std::string to_string() const { error_code error; const std::string str = to_string(error); boost::asio::detail::throw_error(error); return str; } std::string to_string(error_code &error) const { return ""; } static address_svc from_string(const char *str) { error_code error; const address_svc addr = from_string(str, error); boost::asio::detail::throw_error(error); return addr; } static address_svc from_string(const char *str, error_code &error) { address_svc addr; return addr; } static address_svc from_string(const std::string &str) { return from_string(str.c_str()); } static address_svc from_string(const std::string &str, error_code &error) { return from_string(str.c_str(), error); } /// Compare two addresses for equality. friend bool operator==(const address_svc& a1, const address_svc& a2) { return false; } /// Compare two address_svces for inequality. friend bool operator!=(const address_svc& a1, const address_svc& a2) { return !(a1 == a2); } /// Compare address_svces for ordering. friend bool operator<(const address_svc& a1, const address_svc& a2) { return false; } /// Compare address_svces for ordering. friend bool operator>(const address_svc& a1, const address_svc& a2) { return a2 < a1; } /// Compare address_svces for ordering. friend bool operator<=(const address_svc& a1, const address_svc& a2) { return !(a2 < a1); } /// Compare address_svces for ordering. friend bool operator>=(const address_svc& a1, const address_svc& a2) { return !(a1 < a2); } private: detail::atmsvc_addr_type addr_; }; // class address_svc #if !defined(BOOST_NO_IOSTREAM) /// Output an address as a string. /** * Used to output a human-readable string for a specified address. * * @param os The output stream to which the string will be written. * * @param addr The address to be written. * * @return The output stream. * * @relates boost::asio::atm::address_svc */ template <typename Elem, typename Traits> std::basic_ostream<Elem, Traits>& operator<<( std::basic_ostream<Elem, Traits>& os, const address_svc& addr); #endif // !defined(BOOST_NO_IOSTREAM) } // namespace atm } // namespace asio } // namespace boost #endif // BOOST_ASIO_ATM_ADDRESS_SVC_HEAD /// \file boost/asio/atm/basic_endpoint.hpp /// UNCLASSIFIED /// \brief Endpoint for ATM sockets #ifndef BOOST_ASIO_ATM_BASIC_ENDPOINT_HEAD #define BOOST_ASIO_ATM_BASIC_ENDPOINT_HEAD #include <boost/asio.hpp> #include "address.hpp" #include "qos.hpp" #include "detail/endpoint.hpp" namespace boost { namespace asio { namespace atm { template <typename AsynchronousTransferModeProtocol> class basic_endpoint { public: /// The protocol type associated with the endpoint. typedef AsynchronousTransferModeProtocol protocol_type; /// The type of the endpoint structure. This type is dependent on the /// underlying implementation of the socket layer. typedef boost::asio::atm::detail::endpoint endpoint_impl; typedef endpoint_impl::data_type data_type; /// Default constructor. basic_endpoint() : impl_() { } /// Construct an endpoint using an ATM address. This /// constructor may be used for accepting connections on a specific interface /// or for making a connection to a remote endpoint. basic_endpoint(const boost::asio::atm::address& addr) : impl_(addr) { } /// Construct an endpoint using an ATM address and Quality Of Service settings. This /// constructor may be used for accepting connections on a specific interface /// or for making a connection to a remote endpoint. basic_endpoint(const boost::asio::atm::address& addr, const qos::settings &qos) : impl_(addr, qos) { } /// Copy constructor. basic_endpoint(const basic_endpoint& other) : impl_(other.impl_) { } #if defined(BOOST_ASIO_HAS_MOVE) /// Move constructor. basic_endpoint(basic_endpoint&& other) : impl_(other.impl_) { } #endif // defined(BOOST_ASIO_HAS_MOVE) /// Assign from another endpoint. basic_endpoint& operator=(const basic_endpoint& other) { impl_ = other.impl_; return *this; } #if defined(BOOST_ASIO_HAS_MOVE) /// Move-assign from another endpoint. basic_endpoint& operator=(basic_endpoint&& other) { impl_ = other.impl_; return *this; } #endif // defined(BOOST_ASIO_HAS_MOVE) /// The protocol associated with the endpoint. protocol_type protocol() const { if (is_svc()) { return AsynchronousTransferModeProtocol::aal5_svc(); } return AsynchronousTransferModeProtocol::aal5_pvc(); } bool is_pvc() const { return impl_.is_pvc(); } bool is_svc() const { return impl_.is_svc(); } /// Get the underlying endpoint in the native type. data_type* data() { return impl_.data(); } /// Get the underlying endpoint in the native type. const data_type* data() const { return impl_.data(); } /// Get the underlying size of the endpoint in the native type. std::size_t size() const { return impl_.size(); } /// Set the underlying size of the endpoint in the native type. void resize(std::size_t new_size) { return impl_.resize(new_size); } /// Get the capacity of the endpoint in the native type. std::size_t capacity() const { return impl_.capacity(); } /// Get the IP address associated with the endpoint. const boost::asio::atm::address address() const { return impl_.address(); } /// Set the IP address associated with the endpoint. void address(const boost::asio::atm::address& addr) { impl_.address(addr); } /// Compare two endpoints for equality. friend bool operator==(const basic_endpoint<AsynchronousTransferModeProtocol>& e1, const basic_endpoint<AsynchronousTransferModeProtocol>& e2) { return e1.impl_ == e2.impl_; } /// Compare two endpoints for inequality. friend bool operator!=(const basic_endpoint<AsynchronousTransferModeProtocol>& e1, const basic_endpoint<AsynchronousTransferModeProtocol>& e2) { return !(e1 == e2); } /// Compare endpoints for ordering. friend bool operator<(const basic_endpoint<AsynchronousTransferModeProtocol>& e1, const basic_endpoint<AsynchronousTransferModeProtocol>& e2) { return e1.impl_ < e2.impl_; } /// Compare endpoints for ordering. friend bool operator>(const basic_endpoint<AsynchronousTransferModeProtocol>& e1, const basic_endpoint<AsynchronousTransferModeProtocol>& e2) { return e2.impl_ < e1.impl_; } /// Compare endpoints for ordering. friend bool operator<=(const basic_endpoint<AsynchronousTransferModeProtocol>& e1, const basic_endpoint<AsynchronousTransferModeProtocol>& e2) { return !(e2 < e1); } /// Compare endpoints for ordering. friend bool operator>=(const basic_endpoint<AsynchronousTransferModeProtocol>& e1, const basic_endpoint<AsynchronousTransferModeProtocol>& e2) { return !(e1 < e2); } private: // The underlying ATM endpoint. endpoint_impl impl_; }; // class basic_endpoint #if !defined(BOOST_NO_IOSTREAM) /// Output an endpoint as a string. /** * Used to output a human-readable string for a specified endpoint. * * @param os The output stream to which the string will be written. * * @param endpoint The endpoint to be written. * * @return The output stream. * * @relates boost::asio::atm::basic_endpoint */ template <typename Elem, typename Traits, typename AsynchronousTransferModeProtocol> std::basic_ostream<Elem, Traits>& operator<<( std::basic_ostream<Elem, Traits>& os, const basic_endpoint<AsynchronousTransferModeProtocol>& endpoint); #endif // !defined(BOOST_NO_IOSTREAM) } // namespace atm } // namespace asio } // namespace boost #include "basic_endpoint.ipp" #endif // BOOST_ASIO_ATM_BASIC_ENDPOINT_HEAD /// \file boost/asio/atm/basic_endpoint.ipp /// UNCLASSIFIED #ifndef BOOST_ASIO_ATM_BASIC_ENDPOINT_IMPL #define BOOST_ASIO_ATM_BASIC_ENDPOINT_IMPL #include "address.hpp" namespace boost { namespace asio { namespace atm { template <typename Elem, typename Traits> std::basic_ostream<Elem, Traits>& operator<<(std::basic_ostream<Elem, Traits>& os, const address_pvc& addr) { if (os) { os << addr.to_string(); } return os; } template <typename Elem, typename Traits> std::basic_ostream<Elem, Traits>& operator<<(std::basic_ostream<Elem, Traits>& os, const address& addr) { if (os) { os << addr.to_string(); } return os; } #if !defined(BOOST_NO_IOSTREAM) template <typename Elem, typename Traits, typename AsynchronousTransferModeProtocol> std::basic_ostream<Elem, Traits>& operator<<( std::basic_ostream<Elem, Traits>& os, const basic_endpoint<AsynchronousTransferModeProtocol>& endpoint) { if (os) { os << endpoint.address(); } return os; } #endif // !defined(BOOST_NO_IOSTREAM) } // namespace atm } // namespace asio } // namespace boost #endif // BOOST_ASIO_ATM_BASIC_ENDPOINT_IMPL /// \file boost/asio/atm/qos.hpp /// UNCLASSIFIED /// \brief Asynchronous Transfer Mode QOS for Boost ASIO #ifndef BOOST_ASIO_ATM_QOS_HEAD #define BOOST_ASIO_ATM_QOS_HEAD #include <boost/variant.hpp> #include "detail/socket_types.hpp" namespace boost { namespace asio { namespace atm { namespace qos { struct do_not_use_qos { do_not_use_qos() { } }; struct ubr_settings { unsigned long peak_cell_rate; ubr_settings() : peak_cell_rate(0u) { } ubr_settings(const unsigned long r) : peak_cell_rate(r) { } }; struct cbr_settings { unsigned long peak_cell_rate; cbr_settings() : peak_cell_rate(0u) { } }; struct vbr_settings { unsigned long peak_cell_rate; unsigned long substainable_cell_rate; unsigned long max_burst_size; vbr_settings() : peak_cell_rate(0u), substainable_cell_rate(0u), max_burst_size(0u) { } }; struct abr_settings { unsigned long peak_cell_rate; unsigned long minimum_cell_rate; unsigned long allowed_cell_rate; unsigned long initial_cell_rate; unsigned long rate_increase_factor; unsigned long rate_decrease_factor; unsigned long cut_off_decrease_factor; abr_settings() : peak_cell_rate(0u) , minimum_cell_rate(0u) , allowed_cell_rate(0u) , initial_cell_rate(0u) , rate_increase_factor(0u) , rate_decrease_factor(0u) , cut_off_decrease_factor(0u) { } }; typedef boost::variant<do_not_use_qos, ubr_settings, cbr_settings, vbr_settings, abr_settings> settings; } // namespace qos } // namespace atm } // namespace asio } // namespace boost #include "detail/qos.hpp" #endif // BOOST_ASIO_ATM_QOS_HEAD /// \file boost/asio/atm/detail/endpoint.hpp /// UNCLASSIFIED /// \brief Endpoint for ATM sockets #ifndef BOOST_ASIO_ATM_DETAIL_ENDPOINT_HEAD #define BOOST_ASIO_ATM_DETAIL_ENDPOINT_HEAD #include <boost/asio.hpp> #include <boost/variant.hpp> #include "boost/asio/atm/address.hpp" #include "boost/asio/atm/detail/socket_types.hpp" #include "boost/asio/atm/qos.hpp" namespace boost { namespace asio { namespace atm { namespace detail { class endpoint_data_size_visitor : public boost::static_visitor<std::size_t> { public: std::size_t operator()(const atmpvc_endpoint_type& params) const { return sizeof(atmpvc_endpoint_type); } std::size_t operator()(const atmsvc_endpoint_type &ep) const { return sizeof(atmsvc_endpoint_type); } }; // class endpoint_data_size_visitor class endpoint_address_visitor : public boost::static_visitor<boost::asio::atm::address> { public: boost::asio::atm::address operator()(const atmpvc_endpoint_type& ep) const { return boost::asio::atm::address_pvc(ep.native_connection_id()); } boost::asio::atm::address operator()(const atmsvc_endpoint_type &ep) const { return boost::asio::atm::address_svc(ep.native_connection_id()); } }; // class endpoint_data_size_visitor class endpoint { public: typedef boost::asio::atm::detail::atm_endpoint_type data_type; endpoint() : data_() , qos_() { } /// \todo Add QOS parameters to this constructor endpoint(const boost::asio::atm::address& addr, const qos::settings &qos = qos::do_not_use_qos()) : data_() , qos_(qos) { address(addr); } bool is_pvc() const { return boost::get<atmpvc_endpoint_type*>(&data_) != NULL; } bool is_svc() const { return boost::get<atmsvc_endpoint_type*>(&data_) != NULL; } /// Get the underlying endpoint in the native type. data_type* data() { return &data_; } /// Get the underlying endpoint in the native type. const data_type* data() const { return &data_; } std::size_t size() const { return boost::apply_visitor(endpoint_data_size_visitor(), data_); } void resize(const std::size_t new_size) { if (new_size > sizeof(data_type)) { boost::system::error_code ec(boost::asio::error::invalid_argument); boost::asio::detail::throw_error(ec); } } std::size_t capacity() const { return sizeof(data_type); } boost::asio::atm::address address() const { return boost::apply_visitor(endpoint_address_visitor(), data_); } void address(const boost::asio::atm::address& addr) { if (addr.is_pvc()) { const address_pvc my_pvc_addr = addr.to_pvc(); atmpvc_endpoint_type my_data; boost::apply_visitor(boost::asio::atm::qos::detail::pvc_visitor(my_data), qos_); my_data.assign(*my_pvc_addr.data()); data_ = my_data; } } friend bool operator==(const endpoint& e1, const endpoint& e2) { return e1.address() == e2.address(); } /// Compare endpoints for ordering. friend bool operator<(const endpoint& e1, const endpoint& e2) { return e1.address() < e2.address(); } private: data_type data_; qos::settings qos_; }; // class endpoint } // namespace detail } // namespace atm } // namespace asio } // namespace boost #include "boost/asio/atm/detail/impl/endpoint.ipp" #endif // BOOST_ASIO_ATM_DETAIL_ENDPOINT_HEAD /// \file boost/asio/atm/detail/qos.hpp /// UNCLASSIFIED /// \brief Asynchronous Transfer Mode QOS details for Boost ASIO #ifndef BOOST_ASIO_ATM_DETAIL_QOS_HEAD #define BOOST_ASIO_ATM_DETAIL_QOS_HEAD namespace boost { namespace asio { namespace atm { namespace qos { namespace detail { class pvc_visitor : public boost::static_visitor<> { public: pvc_visitor(boost::asio::atm::detail::atmpvc_endpoint_type &p) : boost::static_visitor<>() , data(p) { } void operator()(const do_not_use_qos &) const; void operator()(const ubr_settings &ubr) const; void operator()(const cbr_settings &cbr) const; void operator()(const vbr_settings &vbr) const; void operator()(const abr_settings &abr) const; private: boost::asio::atm::detail::atmpvc_endpoint_type& data; }; } // namespace detail } // namespace qos } // namespace atm } // namespace asio } // namespace boost #endif // BOOST_ASIO_ATM_DETAIL_QOS_HEAD #include "boost/asio/atm/detail/impl/qos.ipp" /// \file boost/asio/atm/detail/socket_ops.hpp /// UNCLASSIFIED /// \brief Asynchronous Transfer Mode socket operations for Boost ASIO #ifndef BOOST_ASIO_ATM_DETAIL_SOCKET_OPS_HEAD #define BOOST_ASIO_ATM_DETAIL_SOCKET_OPS_HEAD #include <boost/variant.hpp> #include <boost/asio.hpp> #include <boost/exception/all.hpp> #include "boost/asio/atm/detail/socket_types.hpp" namespace boost { namespace asio { namespace atm { namespace detail { namespace socket_ops { #if defined(BOOST_WINDOWS) || defined(__CYGWIN__) inline void initialize(atmpvc_addr_type& addr) { memset(&addr, 0, sizeof(atmpvc_addr_type)); } inline void set_itf(const unsigned long itf, atmpvc_addr_type& addr) { addr.DeviceNumber = itf; } inline unsigned long itf(const atmpvc_addr_type& addr) { return addr.DeviceNumber; } inline void set_vci(const unsigned long vci, atmpvc_addr_type& addr) { addr.VCI = vci; } inline unsigned long vci(const atmpvc_addr_type& addr) { return addr.VCI; } inline void set_vpi(const unsigned long vpi, atmpvc_addr_type& addr) { addr.VPI = vpi; } inline unsigned long vpi(const atmpvc_addr_type& addr) { return addr.VPI; } #else // ! (BOOST_WINDOWS || __CYGWIN__) inline void initialize(atmpvc_addr_type& addr) { memset(&addr, 0, sizeof(atmpvc_addr_type)); addr.sap_family = AF_ATMPVC; } inline void set_itf(const unsigned long itf, atmpvc_addr_type& addr) { addr.sap_addr.itf = itf; } inline unsigned long itf(const atmpvc_addr_type& addr) { return addr.sap_addr.itf; } inline void set_vci(const unsigned long vci, atmpvc_addr_type& addr) { addr.sap_addr.vci = vci; } inline unsigned long vci(const atmpvc_addr_type& addr) { return addr.sap_addr.vci; } inline void set_vpi(const unsigned long vpi, atmpvc_addr_type& addr) { addr.sap_addr.vpi = vpi; } inline unsigned long vpi(const atmpvc_addr_type& addr) { return addr.sap_addr.vpi; } #endif // BOOST_WINDOWS || __CYGWIN__ } // namespace socket_ops class bind_endpoint_visitor : public boost::static_visitor<int> { public: bind_endpoint_visitor(const boost::asio::detail::socket_type s, boost::system::error_code &ec) : socket_(s) , ec_(ec) { } /// Set the VCI/VPI pair for a permament virtual circuit (PVC) int operator()(const atmpvc_endpoint_type& params) const; int operator()(const atmsvc_endpoint_type& params) const; private: boost::asio::detail::socket_type socket_; boost::system::error_code& ec_; }; // class bind_endpoint_visitor } // namespace detail } // namespace atm } // namespace asio } // namespace boost namespace boost { namespace asio { namespace detail { namespace socket_ops { BOOST_ASIO_DECL int bind(socket_type s, const boost::asio::atm::detail::atm_endpoint_type* addr, std::size_t addrlen, boost::system::error_code& ec) { return boost::apply_visitor(boost::asio::atm::detail::bind_endpoint_visitor(s, ec), *addr); } } // namespace socket_ops } // namespace detail } // namespace asio } // namespace boost #endif // BOOST_ASIO_ATM_DETAIL_SOCKET_OPS_HEAD /// \file boost/asio/atm/detail/socket_option.hpp /// UNCLASSIFIED /// \brief Asynchronous Transfer Mode socket options for Boost ASIO #ifndef BOOST_ASIO_ATM_DETAIL_SOCKET_OPTION_HEAD #define BOOST_ASIO_ATM_DETAIL_SOCKET_OPTION_HEAD #include <boost/asio.hpp> namespace boost { namespace asio { namespace atm { namespace detail { namespace socket_option { class qos { public: template <typename Protocol> int level(const Protocol& protocol) const { } template <typename Protocol> int name(const Protocol& protocol) const { } template <typename Protocol> void* data(const Protocol& protocol) { } template <typename Protocol> const void* data(const Protocol& protocol) const { } template <typename Protocol> std::size_t size(const Protocol& protocol) const { } template <typename Protocol> void resize(const Protocol& protocol, std::size_t s) { } private: }; // class qos } // namespace socket_option } // namespace detail } // namespace atm } // namespace asio } // namespace boost #endif // BOOST_ASIO_ATM_DETAIL_SOCKET_OPTION_HEAD /// \file boost/asio/atm/detail/socket_types.hpp /// UNCLASSIFIED /// \brief Asynchronous Transfer Mode socket types for Boost ASIO #ifndef BOOST_ASIO_ATM_DETAIL_SOCKET_TYPES_HEAD #define BOOST_ASIO_ATM_DETAIL_SOCKET_TYPES_HEAD #include <string> #include <boost/asio.hpp> #include <boost/variant.hpp> #if defined HAVE_ATM_H extern "C" { # include <atm.h> } #elif defined HAVE_SYS_NETATM_ATM_H # include <sys/netatm/atm.h> #elif defined _WIN32 # include <ws2atm.h> #else # error There is no ATM header to include #endif namespace boost { namespace asio { namespace atm { namespace detail { #if defined(BOOST_WINDOWS) || defined(__CYGWIN__) typedef sockaddr_atm atmsvc_addr_type; typedef ATM_CONNECTION_ID atmpvc_addr_type; /// \note Wrap the ATM_PVC_PARAMS so that I have a place to default construct it. struct atmpvc_endpoint_type { ATM_PVC_PARAMS native_; atmpvc_endpoint_type() : native_() { // Initialize Qos Settings with default values : UBR without specified Qos native_.PvcQos.ReceivingFlowspec.TokenRate = QOS_NOT_SPECIFIED; native_.PvcQos.ReceivingFlowspec.TokenBucketSize = QOS_NOT_SPECIFIED; native_.PvcQos.ReceivingFlowspec.PeakBandwidth = QOS_NOT_SPECIFIED; native_.PvcQos.ReceivingFlowspec.Latency = QOS_NOT_SPECIFIED; native_.PvcQos.ReceivingFlowspec.DelayVariation = QOS_NOT_SPECIFIED; native_.PvcQos.ReceivingFlowspec.ServiceType = SERVICETYPE_BESTEFFORT; native_.PvcQos.ReceivingFlowspec.MaxSduSize = QOS_NOT_SPECIFIED; native_.PvcQos.ReceivingFlowspec.MinimumPolicedSize = QOS_NOT_SPECIFIED; native_.PvcQos.SendingFlowspec.TokenRate = QOS_NOT_SPECIFIED; native_.PvcQos.SendingFlowspec.TokenBucketSize = QOS_NOT_SPECIFIED; native_.PvcQos.SendingFlowspec.PeakBandwidth = QOS_NOT_SPECIFIED; native_.PvcQos.SendingFlowspec.Latency = QOS_NOT_SPECIFIED; native_.PvcQos.SendingFlowspec.DelayVariation = QOS_NOT_SPECIFIED; native_.PvcQos.SendingFlowspec.ServiceType = SERVICETYPE_BESTEFFORT; native_.PvcQos.SendingFlowspec.MaxSduSize = QOS_NOT_SPECIFIED; native_.PvcQos.SendingFlowspec.MinimumPolicedSize = QOS_NOT_SPECIFIED; } const ATM_PVC_PARAMS &native() const { return native_; } const ATM_CONNECTION_ID &native_connection_id() const { return native_.PvcConnectionId; } void assign(const ATM_CONNECTION_ID &i) { native_.PvcConnectionId = i; } }; struct atmsvc_endpoint_type { sockaddr_atm native_; atmsvc_endpoint_type() : native_() { } const sockaddr_atm &native() const { return native_; } const sockaddr_atm &native_connection_id() const { return native_; } void assign(const sockaddr_atm &i) { native_ = i; } }; #else typedef sockaddr_atmsvc atmsvc_addr_type; typedef sockaddr_atmpvc atmpvc_addr_type; typedef atm_qos atm_qos_type; struct atmpvc_endpoint_type { atmpvc_addr_type addr; atm_qos_type qos; atmpvc_endpoint_type() : addr() , qos() { qos.aal = ATM_AAL5; } const atmpvc_addr_type &native() const { return addr; } const atmpvc_addr_type &native_connection_id() const { return addr; } void assign(const atmpvc_addr_type &a) { addr = a; } }; struct atmsvc_endpoint_type { atmsvc_addr_type addr; atm_qos_type qos; const atmsvc_addr_type &native() const { return addr; } const atmsvc_addr_type &native_connection_id() const { return addr; } void assign(const atmsvc_addr_type &a) { addr = a; } }; #endif // BOOST_WINDOWS || __CYGWIN__ typedef boost::variant<atmpvc_endpoint_type, atmsvc_endpoint_type> atm_endpoint_type; } // namespace detail } // namespace atm } // namespace asio } // namespace boost #endif // BOOST_ASIO_ATM_DETAIL_SOCKET_TYPES_HEAD /// \file boost/asio/atm/detail/impl/endpoint.ipp /// UNCLASSIFIED /// \brief Endpoint for ATM sockets #ifndef BOOST_ASIO_ATM_DETAIL_ENDPOINT_IPP #define BOOST_ASIO_ATM_DETAIL_ENDPOINT_IPP namespace boost { namespace asio { namespace atm { namespace detail { #if defined(BOOST_WINDOWS) || defined(__CYGWIN__) int bind_endpoint_visitor::operator()(const atmpvc_endpoint_type& params) const { using boost::asio::detail::socket_ops::error_wrapper; DWORD out_bytes; /// \todo What gets placed in out_bytes? return error_wrapper(WSAIoctl(socket_, SIO_ASSOCIATE_PVC, (LPVOID) &params.native(), sizeof(ATM_PVC_PARAMS), NULL, 0, &out_bytes, NULL, NULL), ec_); } int bind_endpoint_visitor::operator()(const atmsvc_endpoint_type& params) const { ec_ = boost::asio::error::invalid_argument; return -1; } #else // ! (BOOST_WINDOWS || __CYGWIN__) int bind_endpoint_visitor::operator()(const atmpvc_endpoint_type& params) const { // I am not convinced that this is the best place to set the ATM QOS // options, but it makes the implementation consistent with Windows. // Also, it makes the socket constructors that accept an endpoint work. // I probably need an equivalent for "connect" and "listen." boost::asio::detail::socket_ops::state_type my_state; if (const int result = boost::asio::detail::socket_ops::setsockopt(socket_, my_state, SOL_ATM, SO_ATMQOS, &params.qos, sizeof(params.qos), ec_)) { return result; } return boost::asio::detail::socket_ops::bind(socket_, (struct sockaddr *) &params.addr, sizeof(params.addr), ec_); } int bind_endpoint_visitor::operator()(const atmsvc_endpoint_type& params) const { ec_ = boost::asio::error::invalid_argument; return -1; } #endif // end defined(BOOST_WINDOWS) || defined(__CYGWIN__) } // namespace detail } // namespace atm } // namespace asio } // namespace boost #endif // BOOST_ASIO_ATM_DETAIL_ENDPOINT_IPP /// \file boost/asio/atm/detail/impl/qos.ipp /// UNCLASSIFIED /// \brief Asynchronous Transfer Mode QOS implementation #ifndef BOOST_ASIO_ATM_QOS_IPP #define BOOST_ASIO_ATM_QOS_IPP namespace boost { namespace asio { namespace atm { namespace qos { namespace detail { #if defined BOOST_WINDOWS || __CYGWIN__ void pvc_visitor::operator()(const do_not_use_qos &) const { } void pvc_visitor::operator()(const ubr_settings &ubr) const { data.native_.PvcQos.SendingFlowspec.PeakBandwidth = ubr.peak_cell_rate * 48u; } void pvc_visitor::operator()(const cbr_settings &cbr) const { data.native_.PvcQos.SendingFlowspec.ServiceType = SERVICETYPE_GUARANTEED; data.native_.PvcQos.ReceivingFlowspec.ServiceType = SERVICETYPE_GUARANTEED; data.native_.PvcQos.SendingFlowspec.PeakBandwidth = cbr.peak_cell_rate * 48u; } void pvc_visitor::operator()(const vbr_settings &vbr) const { data.native_.PvcQos.SendingFlowspec.ServiceType = SERVICETYPE_CONTROLLEDLOAD; data.native_.PvcQos.ReceivingFlowspec.ServiceType = SERVICETYPE_CONTROLLEDLOAD; data.native_.PvcQos.SendingFlowspec.PeakBandwidth = vbr.peak_cell_rate * 48u; data.native_.PvcQos.SendingFlowspec.TokenRate = vbr.substainable_cell_rate * 48u; data.native_.PvcQos.SendingFlowspec.TokenBucketSize = vbr.max_burst_size * 48u; } void pvc_visitor::operator()(const abr_settings &abr) const { } #else void pvc_visitor::operator()(const do_not_use_qos &) const { data.qos.txtp.traffic_class = ATM_NONE; data.qos.txtp.traffic_class = ATM_NONE; } void pvc_visitor::operator()(const ubr_settings &ubr) const { data.qos.txtp.traffic_class = ATM_UBR; data.qos.rxtp.traffic_class = ATM_UBR; data.qos.rxtp.max_sdu = ubr.peak_cell_rate; data.qos.txtp.max_pcr = ubr.peak_cell_rate; } void pvc_visitor::operator()(const cbr_settings &cbr) const { data.qos.txtp.traffic_class = ATM_CBR; data.qos.rxtp.traffic_class = ATM_CBR; //data.qos.txtp.ServiceType = SERVICETYPE_GUARANTEED; //data.native.qos.rxtp.ServiceType = SERVICETYPE_GUARANTEED; data.qos.txtp.max_pcr = cbr.peak_cell_rate; } void pvc_visitor::operator()(const vbr_settings &vbr) const { data.qos.txtp.traffic_class = ATM_VBR; data.qos.rxtp.traffic_class = ATM_VBR; //data.qos.txtp.ServiceType = SERVICETYPE_CONTROLLEDLOAD; //data.qos.rxtp.ServiceType = SERVICETYPE_CONTROLLEDLOAD; data.qos.txtp.max_pcr = vbr.peak_cell_rate; //data.qos.txtp.TokenRate = vbr.substainable_cell_rate; //data.qos.txtp.TokenBucketSize = vbr.max_burst_size; } void pvc_visitor::operator()(const abr_settings &abr) const { data.qos.txtp.traffic_class = ATM_ABR; data.qos.rxtp.traffic_class = ATM_ABR; } #endif } // namespace detail } // namespace qos } // namespace atm } // namespace asio } // namespace boost #endif // BOOST_ASIO_ATM_QOS_IPP [View Less]

1 0

problem with boost parallel graph dijkstra_shortest_paths
by areslp 20 Jul '12

20 Jul '12

I want to use the parallel version of dijkstra_shortest_paths, here is my code, it works very well with the sequential version of BGL, but can not be compiled with parallel BGL. typedef boost::adjacency_list < boost::vecS, boost::vecS, boost::undirectedS, boost::no_property, boost::property < boost::edge_weight_t, double > > graph_t; typedef boost::graph_traits < graph_t >::vertex_descriptor vertex_descriptor; typedef boost::graph_traits < graph_t >::edge_descriptor … [View More]edge_descriptor; typedef std::pair<int, int> Edge; template <class Vertex> struct target_visitor : public default_dijkstra_visitor { target_visitor(vector<bool>* vec,int total) : vec_(vec),num_(0),total_(total),examined_(0) { } template <class Graph> void examine_vertex(Vertex v, Graph& g) { examined_++; if ((*vec_)[v]) { //visited, set false to prevent multi visit (*vec_)[v]=false; num_++; //cout<<"v:"<<v<<",total:"<<total_<<",num:"<<num_<<",examined_:"<<examined_<<endl; } if (total_==num_) { //cout<<"OK. break, Total point size is:"<<vec_->size()<<",examined_ point size is:"<<examined_<<endl; //all vertex in v have been found throw std::exception(); } } private: vector<bool>* vec_; int num_; int total_; int examined_; }; template <class Vertex> target_visitor<Vertex> target_visit(vector<bool>* u,int total) { return target_visitor<Vertex>(u,total); } void BaseFilter::getShortestPathInNRing(int source,int num,std::vector<bool>& tar,std::vector<vertex_descriptor>& p,std::vector<double>& d){ vertex_descriptor sou = vertex(source, g_); assert(num_vertices(g_)==mesh_->m_vecVertex.size()); property_map<graph_t, edge_weight_t>::type weightmap = get(edge_weight, g_); property_map<graph_t, vertex_index_t>::type indexmap = get(vertex_index, g_); try { dijkstra_shortest_paths(g_, sou, &p[0], &d[0], weightmap, indexmap, std::less<double>(), closed_plus<double>(), (std::numeric_limits<double>::max)(), 0, target_visitor<vertex_descriptor>(&tar,num)); //dijkstra_shortest_paths(g_, sou, predecessor_map(&p[0]).distance_map(&d[0])); } catch (std::exception e) { } } The compile errors are: Error 11 error C2664: 'boost::put' : cannot convert parameter 2 from 'boost::detail::parallel::global_descriptor<LocalDescriptor>' to 'ptrdiff_t' C:\boost_1_49_0\boost_1_49_0\boost\graph\distributed\crauser_et_al_shortest_paths.hpp 584 Error 12 error C2664: 'boost::put' : cannot convert parameter 2 from 'boost::detail::parallel::global_descriptor<LocalDescriptor>' to 'ptrdiff_t' C:\boost_1_49_0\boost_1_49_0\boost\graph\distributed\crauser_et_al_shortest_paths.hpp 585 Error 13 error C2664: 'boost::put' : cannot convert parameter 2 from 'boost::detail::parallel::global_descriptor<LocalDescriptor>' to 'ptrdiff_t' C:\boost_1_49_0\boost_1_49_0\boost\graph\distributed\crauser_et_al_shortest_paths.hpp 587 -- Best Regards Areslp [View Less]

2 1

Can anybody help to check my Boost code?
by JIA Pei 19 Jul '12

19 Jul '12

Hi, all: My environment: Ubuntu 12.04 + libboost1.48-dev ( 1.48.0-3(precise) ) My code patch: > bool VO_IO::ScanDirectory( const path &dir_path, > const string &file_extension, > vector<string>& files) > { > if ( !exists( dir_path ) ) > { > return false; > } > directory_iterator end_itr; > for ( directory_iterator itr(dir_path); itr != end_itr; ++itr ) > … [View More]

2 2

[Boost.Exception] A couple of unspotted areas
by Alexander Mingalev 19 Jul '12

19 Jul '12

Hi, I'm trying to use Boost.Exception library and I have some issues here. 1. How to build exception hierarchy correctly? According to examples I wrote: #include <iostream> #include <boost/exception/all.hpp> struct Error1 : virtual public std::exception, virtual public boost::exception { Error1(const char* msg) : std::exception(msg) {} }; struct Error2 : virtual public Error1 { Error2(const char* msg) : Error1(msg) {} }; ... std::cout << Error2("zzz").what() <… [View More]

3 2

Extracting a boost::function from a boost::signals2::signal
by Chris Stankevitz 19 Jul '12

19 Jul '12

Hello, I would like to create an "Interceptor" class that can generically receive a void-returning signal with n arguments (as something like a boost::function<void()>) and, at runtime, decide whether the signal will be delivered to the final slot. Or perhaps even deliver the signal at some later time. Psuedocode might look like this: class Interceptor { template<class Signal> void Connect(Signal& signal, const Signal::slot_type& slot) { signal.connect_generic(… [View More]

1 0

[BJam] managing including order
by Marc-Antoine ARNAUD 19 Jul '12

19 Jul '12

Hi, I'm currently tring to use including ordering into BJam files. I have 2 libraries - boostHack (header only library) defined by: alias boostHack : # no sources : # no build requirements : # no default build : <include>. ; and - libSupport defined with: project : requirements <include>$(BOOST_HACK)&&$(BOOST_LIBS) <include>include <link>static : usage-requirements <include>include <include>../../tuttle/src : … [View More]

1 0

Starting with boost
by Ronny Herzog 19 Jul '12

19 Jul '12

Dear all, I want to start using boost and tried the steps provided in http://www.boost.org/doc/libs/1_43_0/more/getting_started/windows.html. <http://www.boost.org/doc/libs/1_43_0/more/getting_started/windows.html#auto…> My system is Windows 7 with MS VC 2008 and I would like to use boost from the command line. I run bootstrap.bat and bjam.exe to build all libraries. However, when I want to compile the example file (http://www.boost.org/doc/libs/1_43_0/more/getting_started/windows.… [View More]

3 3

Parsing a Windows/DOS file path with Spirit
by Yves Dolce 19 Jul '12

19 Jul '12

I've started learning Spirit a couple of days ago and I'd like to know if anyone already implemented a parser for a Windows file path. A local one with a drive letter, not a general UNC. If so, can you share it? That would help me quite a lot to go past the number/xml related examples in the tutorials. Thanks.

1 0

Build Boost 1.50 on Windows XP for MSVS2008
by Boost lzw 19 Jul '12

19 Jul '12

Hi there, I am wondering if anyone here have built 1.50 on Windows XP for MSVS2008 and can kindly share what exact commands in command line that I should use to manaully build everything from the sorce for use with MSVS2008. I have downloaded boost 1.50 and placed it under "C:\Program Files\boost_1_50_0\" folder and can modify the folder when building. I read here that someone tried something like: cd "C:\Program Files\boost_1_50_0\" bootstrap.bat bjam.exe but I could not find "bjam.exe". I … [View More]

5 11

Distributed breadth first search MPI_Unpack runtime error
by Clara Moore 18 Jul '12

18 Jul '12

Hi, I'm having a runtime error that I can't seem to figure out how to fix. When I create and breadth first search a graph with 1,000,000 vertices my code works fine, but if I create and breadth first search a graph with 2,000,000 vertices then I get an MPI_Unpack runtime error. From a stack trace I believe that the code is failing on a call to synchronize the first time that the queue is checked for being empty within the breadth first search code. Can anyone tell me what is wrong in my code … [View More]

1 0

boost numeric bindings - lartg
by Peter Man 18 Jul '12

18 Jul '12

Hi, I'm using the numeric bindings library, and am trying to generate a plane rotation. I've done this using the blas::rotg function, but was hoping to try out the more accurate lapack::lartg function. However, I cannot find this function. Is this missing from the library or have I just not looked hard enough? Thanks in advance! Peter

2 1

Re: [Boost-users] filesystem directory_iterator run-time error during construction after upgrading to OSX Lion
by Thibaut LEPAGE 18 Jul '12

18 Jul '12

Hello, I have a program using a directory_iterator which worked well until yesterday (Mac OSX Lion, g++ version 4.2 and boost version 1.49). Then I upgraded g++ to 4.7 and now the program produces a runtime error "pointer being freed was not allocated" when trying to create the directory_iterator. Thibaut Lepage

1 0

How to make is_arithmetic true for a UDT
by Paul A. Bristow 17 Jul '12

17 Jul '12

I am facing the need to get my User Defined Type to return true from boost::is_arithmetic (This is to meet a check for autoprefixing in Boost.Units) There was some discussion on this issue before, http://lists.boost.org/boost-users/2007/10/31538.php but I am not clear if it reached a satisfactory conclusion. (Nor that I fully understand what is being proposed). A cut-down example is a Trivial UDT that does exactly same as double. (My actual example has template parameter for floating-… [View More]

3 6