include/libtorrent/variant_stream.hpp

   1 // Copyright Daniel Wallin and Arvid Norberg 2007.
   2 // Use, modification and distribution is
   3 // subject to the Boost Software License, Version 1.0. (See accompanying
   4 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
   5
   6 #ifndef VARIANT_STREAM_070211_HPP
   7 # define VARIANT_STREAM_070211_HPP
   8
   9 # include <boost/variant.hpp>
  10
  11 # include <boost/mpl/vector.hpp>
  12 # include <boost/mpl/void.hpp>
  13 # include <boost/mpl/remove.hpp>
  14 # include <boost/mpl/transform.hpp>
  15 # include <boost/mpl/size.hpp>
  16
  17 # include <boost/preprocessor/repetition/enum_params.hpp>
  18 # include <boost/preprocessor/repetition/enum_binary_params.hpp>
  19 # include <boost/preprocessor/facilities/intercept.hpp>
  20
  21 # include <boost/type_traits/add_pointer.hpp>
  22 # include <boost/noncopyable.hpp>
  23
  24 #if BOOST_VERSION < 103500
  25 #include <asio/io_service.hpp>
  26 #else
  27 #include <boost/asio/io_service.hpp>
  28 #endif
  29
  30 # define NETWORK_VARIANT_STREAM_LIMIT 5
  31
  32 namespace libtorrent {
  33
  34 namespace aux
  35 {
  36
  37   struct delete_visitor
  38     : boost::static_visitor<>
  39   {
  40       template <class T>
  41       void operator()(T* p) const
  42       {
  43           delete p;
  44       }
  45
  46       void operator()(boost::blank) const
  47       {}
  48   };
  49
  50 // -------------- io_control -----------
  51
  52   template<class IO_Control_Command>
  53   struct io_control_visitor_ec: boost::static_visitor<>
  54   {
  55       io_control_visitor_ec(IO_Control_Command& ioc, error_code& ec_)
  56           : ioc(ioc), ec(ec_) {}
  57
  58       template <class T>
  59       void operator()(T* p) const
  60       {
  61           p->io_control(ioc, ec);
  62       }
  63
  64       void operator()(boost::blank) const
  65       {}
  66
  67       IO_Control_Command& ioc;
  68       error_code& ec;
  69   };
  70
  71   template<class IO_Control_Command>
  72   struct io_control_visitor
  73       : boost::static_visitor<>
  74   {
  75       io_control_visitor(IO_Control_Command& ioc)
  76           : ioc(ioc) {}
  77
  78       template <class T>
  79       void operator()(T* p) const
  80       {
  81           p->io_control(ioc);
  82       }
  83
  84       void operator()(boost::blank) const
  85       {}
  86
  87       IO_Control_Command& ioc;
  88   };
  89 // -------------- async_connect -----------
  90
  91   template <class EndpointType, class Handler>
  92   struct async_connect_visitor
  93     : boost::static_visitor<>
  94   {
  95       async_connect_visitor(EndpointType const& endpoint, Handler const& handler)
  96         : endpoint(endpoint)
  97         , handler(handler)
  98       {}
  99
 100       template <class T>
 101       void operator()(T* p) const
 102       {
 103           p->async_connect(endpoint, handler);
 104       }
 105
 106       void operator()(boost::blank) const
 107       {}
 108
 109       EndpointType const& endpoint;
 110       Handler const& handler;
 111   };
 112
 113 // -------------- bind -----------
 114
 115   template <class EndpointType>
 116   struct bind_visitor_ec
 117     : boost::static_visitor<>
 118   {
 119       bind_visitor_ec(EndpointType const& ep, error_code& ec_)
 120         : endpoint(ep)
 121         , ec(ec_)
 122       {}
 123
 124       template <class T>
 125       void operator()(T* p) const
 126       { p->bind(endpoint, ec); }
 127
 128       void operator()(boost::blank) const {}
 129
 130       EndpointType const& endpoint;
 131       error_code& ec;
 132   };
 133
 134   template <class EndpointType>
 135   struct bind_visitor
 136     : boost::static_visitor<>
 137   {
 138       bind_visitor(EndpointType const& ep)
 139         : endpoint(ep)
 140       {}
 141
 142       template <class T>
 143       void operator()(T* p) const
 144       { p->bind(endpoint); }
 145
 146       void operator()(boost::blank) const {}
 147
 148       EndpointType const& endpoint;
 149   };
 150
 151 // -------------- open -----------
 152
 153   template <class Protocol>
 154   struct open_visitor_ec
 155     : boost::static_visitor<>
 156   {
 157       open_visitor_ec(Protocol const& p, error_code& ec_)
 158         : proto(p)
 159         , ec(ec_)
 160       {}
 161
 162       template <class T>
 163       void operator()(T* p) const
 164       { p->open(proto, ec); }
 165
 166       void operator()(boost::blank) const {}
 167
 168       Protocol const& proto;
 169       error_code& ec;
 170   };
 171
 172   template <class Protocol>
 173   struct open_visitor
 174     : boost::static_visitor<>
 175   {
 176       open_visitor(Protocol const& p)
 177         : proto(p)
 178       {}
 179
 180       template <class T>
 181       void operator()(T* p) const
 182       { p->open(proto); }
 183
 184       void operator()(boost::blank) const {}
 185
 186       Protocol const& proto;
 187   };
 188
 189 // -------------- is_open -----------
 190
 191   struct is_open_visitor
 192     : boost::static_visitor<bool>
 193   {
 194       is_open_visitor() {}
 195
 196       template <class T>
 197       bool operator()(T const* p) const
 198       { return p->is_open(); }
 199
 200       bool operator()(boost::blank) const { return false; }
 201   };
 202
 203 // -------------- close -----------
 204
 205   struct close_visitor_ec
 206     : boost::static_visitor<>
 207   {
 208       close_visitor_ec(error_code& ec_)
 209         : ec(ec_)
 210       {}
 211
 212       template <class T>
 213       void operator()(T* p) const
 214       { p->close(ec); }
 215
 216       void operator()(boost::blank) const {}
 217
 218       error_code& ec;
 219   };
 220
 221   struct close_visitor
 222     : boost::static_visitor<>
 223   {
 224       template <class T>
 225       void operator()(T* p) const
 226       { p->close(); }
 227
 228       void operator()(boost::blank) const {}
 229   };
 230
 231 // -------------- remote_endpoint -----------
 232
 233   template <class EndpointType>
 234   struct remote_endpoint_visitor_ec
 235     : boost::static_visitor<EndpointType>
 236   {
 237       remote_endpoint_visitor_ec(error_code& ec_)
 238         : ec(ec_)
 239       {}
 240
 241       template <class T>
 242       EndpointType operator()(T const* p) const
 243       { return p->remote_endpoint(ec); }
 244
 245       EndpointType operator()(boost::blank) const
 246       { return EndpointType(); }
 247
 248       error_code& ec;
 249   };
 250
 251   template <class EndpointType>
 252   struct remote_endpoint_visitor
 253     : boost::static_visitor<EndpointType>
 254   {
 255       template <class T>
 256       EndpointType operator()(T const* p) const
 257       { return p->remote_endpoint(); }
 258
 259       EndpointType operator()(boost::blank) const
 260       { return EndpointType(); }
 261   };
 262
 263 // -------------- set_option -----------
 264
 265   template <class SettableSocketOption>
 266   struct set_option_visitor
 267     : boost::static_visitor<>
 268   {
 269       set_option_visitor(SettableSocketOption const& opt)
 270         : opt_(opt)
 271       {}
 272
 273       template <class T>
 274       void operator()(T* p) const
 275       { p->set_option(opt_); }
 276
 277       void operator()(boost::blank) const {}
 278
 279       SettableSocketOption const& opt_;
 280   };
 281
 282   template <class SettableSocketOption>
 283   struct set_option_visitor_ec
 284     : boost::static_visitor<error_code>
 285   {
 286       set_option_visitor_ec(SettableSocketOption const& opt, error_code& ec)
 287         : opt_(opt)
 288         , ec_(ec)
 289       {}
 290
 291       template <class T>
 292       error_code operator()(T* p) const
 293       { return p->set_option(opt_, ec_); }
 294
 295       error_code operator()(boost::blank) const
 296       { return ec_; }
 297
 298       SettableSocketOption const& opt_;
 299       error_code& ec_;
 300   };
 301
 302 // -------------- local_endpoint -----------
 303
 304   template <class EndpointType>
 305   struct local_endpoint_visitor_ec
 306     : boost::static_visitor<EndpointType>
 307   {
 308       local_endpoint_visitor_ec(error_code& ec_)
 309         : ec(ec_)
 310       {}
 311
 312       template <class T>
 313       EndpointType operator()(T const* p) const
 314       {
 315           return p->local_endpoint(ec);
 316       }
 317
 318       EndpointType operator()(boost::blank) const
 319       {
 320           return EndpointType();
 321       }
 322
 323       error_code& ec;
 324   };
 325
 326   template <class EndpointType>
 327   struct local_endpoint_visitor
 328     : boost::static_visitor<EndpointType>
 329   {
 330       template <class T>
 331       EndpointType operator()(T const* p) const
 332       {
 333           return p->local_endpoint();
 334       }
 335
 336       EndpointType operator()(boost::blank) const
 337       {
 338           return EndpointType();
 339       }
 340   };
 341
 342 // -------------- async_read_some -----------
 343
 344   template <class Mutable_Buffers, class Handler>
 345   struct async_read_some_visitor
 346     : boost::static_visitor<>
 347   {
 348       async_read_some_visitor(Mutable_Buffers const& buffers, Handler const& handler)
 349         : buffers(buffers)
 350         , handler(handler)
 351       {}
 352
 353       template <class T>
 354       void operator()(T* p) const
 355       {
 356           p->async_read_some(buffers, handler);
 357       }
 358       void operator()(boost::blank) const
 359       {}
 360
 361       Mutable_Buffers const& buffers;
 362       Handler const& handler;
 363   };
 364
 365 // -------------- read_some -----------
 366
 367   template <class Mutable_Buffers>
 368   struct read_some_visitor
 369     : boost::static_visitor<std::size_t>
 370   {
 371       read_some_visitor(Mutable_Buffers const& buffers)
 372         : buffers(buffers)
 373       {}
 374
 375       template <class T>
 376       std::size_t operator()(T* p) const
 377       { return p->read_some(buffers); }
 378
 379       std::size_t operator()(boost::blank) const
 380       { return 0; }
 381
 382       Mutable_Buffers const& buffers;
 383   };
 384
 385   template <class Mutable_Buffers>
 386   struct read_some_visitor_ec
 387     : boost::static_visitor<std::size_t>
 388   {
 389       read_some_visitor_ec(Mutable_Buffers const& buffers, error_code& ec_)
 390         : buffers(buffers)
 391         , ec(ec_)
 392       {}
 393
 394       template <class T>
 395       std::size_t operator()(T* p) const
 396       { return p->read_some(buffers, ec); }
 397
 398       std::size_t operator()(boost::blank) const
 399       { return 0; }
 400
 401       Mutable_Buffers const& buffers;
 402       error_code& ec;
 403   };
 404
 405 // -------------- async_write_some -----------
 406
 407   template <class Const_Buffers, class Handler>
 408   struct async_write_some_visitor
 409     : boost::static_visitor<>
 410   {
 411       async_write_some_visitor(Const_Buffers const& buffers, Handler const& handler)
 412         : buffers(buffers)
 413         , handler(handler)
 414       {}
 415
 416       template <class T>
 417       void operator()(T* p) const
 418       {
 419           p->async_write_some(buffers, handler);
 420       }
 421
 422       void operator()(boost::blank) const
 423       {}
 424
 425       Const_Buffers const& buffers;
 426       Handler const& handler;
 427   };
 428
 429 // -------------- in_avail -----------
 430
 431   struct in_avail_visitor_ec
 432     : boost::static_visitor<std::size_t>
 433   {
 434       in_avail_visitor_ec(error_code& ec_)
 435         : ec(ec_)
 436       {}
 437
 438       template <class T>
 439       std::size_t operator()(T const* p) const
 440       {
 441           return p->in_avail(ec);
 442       }
 443
 444       std::size_t operator()(boost::blank) const
 445       {
 446           return 0;
 447       }
 448
 449       error_code& ec;
 450   };
 451
 452   struct in_avail_visitor
 453     : boost::static_visitor<std::size_t>
 454   {
 455       template <class T>
 456       std::size_t operator()(T const* p) const
 457       {
 458           return p->in_avail();
 459       }
 460
 461       void operator()(boost::blank) const
 462       {}
 463   };
 464
 465 // -------------- io_service -----------
 466
 467   template <class IOService>
 468   struct io_service_visitor
 469     : boost::static_visitor<IOService&>
 470   {
 471       template <class T>
 472       IOService& operator()(T* p) const
 473       {
 474           return p->get_io_service();
 475       }
 476
 477       IOService& operator()(boost::blank) const
 478       {
 479           return *(IOService*)0;
 480       }
 481   };
 482
 483 // -------------- lowest_layer -----------
 484
 485   template <class LowestLayer>
 486   struct lowest_layer_visitor
 487     : boost::static_visitor<LowestLayer&>
 488   {
 489       template <class T>
 490       LowestLayer& operator()(T* p) const
 491       {
 492           return p->lowest_layer();
 493       }
 494
 495       LowestLayer& operator()(boost::blank) const
 496       {
 497           return *(LowestLayer*)0;
 498       }
 499   };
 500
 501 } // namespace aux
 502
 503 template <
 504     BOOST_PP_ENUM_BINARY_PARAMS(
 505         NETWORK_VARIANT_STREAM_LIMIT, class S, = boost::mpl::void_ BOOST_PP_INTERCEPT
 506     )
 507 >
 508 class variant_stream : boost::noncopyable
 509 {
 510 public:
 511     typedef BOOST_PP_CAT(boost::mpl::vector, NETWORK_VARIANT_STREAM_LIMIT)<
 512         BOOST_PP_ENUM_PARAMS(NETWORK_VARIANT_STREAM_LIMIT, S)
 513     > types0;
 514
 515     typedef typename boost::mpl::remove<types0, boost::mpl::void_>::type types;
 516
 517     typedef typename boost::make_variant_over<
 518         typename boost::mpl::push_back<
 519             typename boost::mpl::transform<
 520                 types
 521               , boost::add_pointer<boost::mpl::_>
 522             >::type
 523           , boost::blank
 524         >::type
 525     >::type variant_type;
 526
 527     typedef typename S0::lowest_layer_type lowest_layer_type;
 528     typedef typename S0::endpoint_type endpoint_type;
 529     typedef typename S0::protocol_type protocol_type;
 530
 531     explicit variant_stream(io_service& ios)
 532         : m_io_service(ios), m_variant(boost::blank()) {}
 533
 534     template <class S>
 535     void instantiate(io_service& ios)
 536     {
 537         TORRENT_ASSERT(&ios == &m_io_service);
 538         std::auto_ptr<S> owned(new S(ios));
 539         boost::apply_visitor(aux::delete_visitor(), m_variant);
 540         m_variant = owned.get();
 541         owned.release();
 542     }
 543
 544     template <class S>
 545     S& get()
 546     {
 547         return *boost::get<S*>(m_variant);
 548     }
 549
 550     bool instantiated() const
 551     {
 552         return m_variant.which() != boost::mpl::size<types>::value;
 553     }
 554
 555     ~variant_stream()
 556     {
 557         boost::apply_visitor(aux::delete_visitor(), m_variant);
 558     }
 559
 560     template <class Mutable_Buffers>
 561     std::size_t read_some(Mutable_Buffers const& buffers, error_code& ec)
 562     {
 563         TORRENT_ASSERT(instantiated());
 564         return boost::apply_visitor(
 565             aux::read_some_visitor_ec<Mutable_Buffers>(buffers, ec)
 566           , m_variant
 567         );
 568     }
 569
 570     template <class Mutable_Buffers>
 571     std::size_t read_some(Mutable_Buffers const& buffers)
 572     {
 573         TORRENT_ASSERT(instantiated());
 574         return boost::apply_visitor(
 575             aux::read_some_visitor<Mutable_Buffers>(buffers)
 576           , m_variant
 577         );
 578     }
 579
 580     template <class Mutable_Buffers, class Handler>
 581     void async_read_some(Mutable_Buffers const& buffers, Handler const& handler)
 582     {
 583         TORRENT_ASSERT(instantiated());
 584         boost::apply_visitor(
 585             aux::async_read_some_visitor<Mutable_Buffers, Handler>(buffers, handler)
 586           , m_variant
 587         );
 588     }
 589
 590     template <class Const_Buffers, class Handler>
 591     void async_write_some(Const_Buffers const& buffers, Handler const& handler)
 592     {
 593         TORRENT_ASSERT(instantiated());
 594         boost::apply_visitor(
 595             aux::async_write_some_visitor<Const_Buffers, Handler>(buffers, handler)
 596           , m_variant
 597         );
 598     }
 599
 600     template <class Handler>
 601     void async_connect(endpoint_type const& endpoint, Handler const& handler)
 602     {
 603         TORRENT_ASSERT(instantiated());
 604         boost::apply_visitor(
 605             aux::async_connect_visitor<endpoint_type, Handler>(endpoint, handler), m_variant
 606         );
 607     }
 608
 609     template <class IO_Control_Command>
 610     void io_control(IO_Control_Command& ioc)
 611     {
 612         TORRENT_ASSERT(instantiated());
 613         boost::apply_visitor(
 614             aux::io_control_visitor<IO_Control_Command>(ioc), m_variant
 615         );
 616     }
 617
 618     template <class IO_Control_Command>
 619     void io_control(IO_Control_Command& ioc, error_code& ec)
 620     {
 621         TORRENT_ASSERT(instantiated());
 622         boost::apply_visitor(
 623             aux::io_control_visitor_ec<IO_Control_Command>(ioc, ec)
 624             , m_variant
 625         );
 626     }
 627
 628     void bind(endpoint_type const& endpoint)
 629     {
 630         TORRENT_ASSERT(instantiated());
 631         boost::apply_visitor(aux::bind_visitor<endpoint_type>(endpoint), m_variant);
 632     }
 633
 634     void bind(endpoint_type const& endpoint, error_code& ec)
 635     {
 636         TORRENT_ASSERT(instantiated());
 637         boost::apply_visitor(
 638             aux::bind_visitor_ec<endpoint_type>(endpoint, ec), m_variant
 639         );
 640     }
 641
 642     void open(protocol_type const& p)
 643     {
 644         TORRENT_ASSERT(instantiated());
 645         boost::apply_visitor(aux::open_visitor<protocol_type>(p), m_variant);
 646     }
 647
 648     void open(protocol_type const& p, error_code& ec)
 649     {
 650         TORRENT_ASSERT(instantiated());
 651         boost::apply_visitor(
 652             aux::open_visitor_ec<protocol_type>(p, ec), m_variant
 653         );
 654     }
 655
 656     bool is_open() const
 657     {
 658         return boost::apply_visitor(aux::is_open_visitor(), m_variant);
 659     }
 660
 661     void close()
 662     {
 663         if (!instantiated()) return;
 664         boost::apply_visitor(aux::close_visitor(), m_variant);
 665     }
 666
 667     void close(error_code& ec)
 668     {
 669         if (!instantiated()) return;
 670         boost::apply_visitor(
 671             aux::close_visitor_ec(ec), m_variant
 672         );
 673     }
 674
 675     std::size_t in_avail() const
 676     {
 677         TORRENT_ASSERT(instantiated());
 678         return boost::apply_visitor(aux::in_avail_visitor(), m_variant);
 679     }
 680
 681     std::size_t in_avail(error_code& ec) const
 682     {
 683         TORRENT_ASSERT(instantiated());
 684         return boost::apply_visitor(
 685             aux::in_avail_visitor_ec(ec), m_variant
 686         );
 687     }
 688
 689     endpoint_type remote_endpoint() const
 690     {
 691         TORRENT_ASSERT(instantiated());
 692         return boost::apply_visitor(aux::remote_endpoint_visitor<endpoint_type>(), m_variant);
 693     }
 694
 695     endpoint_type remote_endpoint(error_code& ec) const
 696     {
 697         TORRENT_ASSERT(instantiated());
 698         return boost::apply_visitor(
 699             aux::remote_endpoint_visitor_ec<endpoint_type>(ec), m_variant
 700         );
 701     }
 702
 703     template <class SettableSocketOption>
 704     void set_option(SettableSocketOption const& opt)
 705     {
 706         TORRENT_ASSERT(instantiated());
 707         boost::apply_visitor(aux::set_option_visitor<SettableSocketOption>(opt)
 708             , m_variant);
 709     }
 710
 711     template <class SettableSocketOption>
 712     error_code set_option(SettableSocketOption const& opt, error_code& ec)
 713     {
 714         TORRENT_ASSERT(instantiated());
 715         return boost::apply_visitor(aux::set_option_visitor_ec<SettableSocketOption>(opt, ec)
 716             , m_variant);
 717     }
 718
 719     endpoint_type local_endpoint() const
 720     {
 721         TORRENT_ASSERT(instantiated());
 722         return boost::apply_visitor(aux::local_endpoint_visitor<endpoint_type>(), m_variant);
 723     }
 724
 725     endpoint_type local_endpoint(error_code& ec) const
 726     {
 727         TORRENT_ASSERT(instantiated());
 728         return boost::apply_visitor(
 729             aux::local_endpoint_visitor_ec<endpoint_type>(ec), m_variant
 730         );
 731     }
 732
 733     io_service& get_io_service()
 734     {
 735         return m_io_service;
 736     }
 737
 738     lowest_layer_type& lowest_layer()
 739     {
 740         TORRENT_ASSERT(instantiated());
 741         return boost::apply_visitor(
 742             aux::lowest_layer_visitor<lowest_layer_type>(), m_variant
 743         );
 744     }
 745
 746 private:
 747     io_service& m_io_service;
 748     variant_type m_variant;
 749 };
 750
 751 } // namespace libtorrent
 752
 753 #endif // VARIANT_STREAM_070211_HPP
 754