Socket/ClientSocketHandle.cti

   1 // $Id$
   2 //
   3 // Copyright (C) 2006
   4 // Fraunhofer Institut fuer offene Kommunikationssysteme (FOKUS)
   5 // Kompetenzzentrum fuer Satelitenkommunikation (SatCom)
   6 //     Stefan Bund <stefan.bund@fokus.fraunhofer.de>
   7 //
   8 // This program is free software; you can redistribute it and/or modify
   9 // it under the terms of the GNU General Public License as published by
  10 // the Free Software Foundation; either version 2 of the License, or
  11 // (at your option) any later version.
  12 //
  13 // This program is distributed in the hope that it will be useful,
  14 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 // GNU General Public License for more details.
  17 //
  18 // You should have received a copy of the GNU General Public License
  19 // along with this program; if not, write to the
  20 // Free Software Foundation, Inc.,
  21 // 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  22
  23 /** \file
  24     \brief ClientSocketHandle inline template implementation
  25  */
  26
  27 #include "ClientSocketHandle.ih"
  28
  29 // Custom includes
  30 #include <typeinfo>
  31
  32 #define prefix_ inline
  33 ///////////////////////////////cti.p///////////////////////////////////////
  34
  35 ///////////////////////////////////////////////////////////////////////////
  36 // senf::detail::ReadRange<Policy,ForwardWritableRange,true>
  37
  38 template <class Handle, class ForwardWritableRange>
  39 prefix_ typename boost::range_iterator<ForwardWritableRange>::type
  40 senf::detail::ReadRange<Handle,ForwardWritableRange,true>::read(Handle & handle,
  41                                                                 ForwardWritableRange & range)
  42 {
  43     typename boost::range_iterator<ForwardWritableRange>::type const i (boost::begin(range));
  44     char * const ic (reinterpret_cast<char*>(storage_iterator(i)));
  45     return i + (handle.read( ic,
  46                              reinterpret_cast<char*>(storage_iterator(boost::end(range))) )
  47                 - ic);
  48 }
  49
  50 template <class Handle, class ForwardWritableRange>
  51 prefix_ typename boost::range_iterator<ForwardWritableRange>::type
  52 senf::detail::ReadRange<Handle,ForwardWritableRange,true>::
  53 readfrom(Handle & handle, ForwardWritableRange & range, typename Handle::Address & addr)
  54 {
  55     typename boost::range_iterator<ForwardWritableRange>::type const i (boost::begin(range));
  56     char * const ic (reinterpret_cast<char*>(storage_iterator(i)));
  57     return i + (handle.readfrom( ic,
  58                                  reinterpret_cast<char*>(storage_iterator(boost::end(range))),
  59                                  addr )
  60                 - ic);
  61 }
  62
  63 ///////////////////////////////////////////////////////////////////////////
  64 // senf::detail::WriteRange<Handle, ForwardReadableRange, true>
  65
  66 template <class Handle, class ForwardReadableRange>
  67 prefix_ typename boost::range_const_iterator<ForwardReadableRange>::type
  68 senf::detail::WriteRange<Handle, ForwardReadableRange, true>::
  69 write(Handle & handle, ForwardReadableRange & range)
  70 {
  71     typename boost::range_const_iterator<ForwardReadableRange>::type const i
  72         (boost::const_begin(range));
  73     char const * const ic (reinterpret_cast<char const *>(storage_iterator(i)));
  74     return i + (handle.write(ic,
  75                              reinterpret_cast<char const *>(
  76                                  storage_iterator(boost::const_end(range))))
  77                 - ic);
  78 }
  79
  80 template <class Handle, class ForwardReadableRange>
  81 prefix_ typename boost::range_const_iterator<ForwardReadableRange>::type
  82 senf::detail::WriteRange<Handle, ForwardReadableRange, true>::
  83 writeto(Handle & handle, ForwardReadableRange & range, typename Handle::Address const & addr)
  84 {
  85     typename boost::range_const_iterator<ForwardReadableRange>::type const i
  86         (boost::const_begin(range));
  87     char const * const ic (reinterpret_cast<char const *>(storage_iterator(i)));
  88     return i + (handle.writeto(addr,
  89                                ic,
  90                                reinterpret_cast<char const *>(
  91                                    storage_iterator(boost::const_end(range))))
  92                 - ic);
  93 }
  94
  95 ///////////////////////////////////////////////////////////////////////////
  96 // senf::ClientSocketHandle<Policy>
  97
  98 ////////////////////////////////////////
  99 // structors
 100
 101 template <class Policy>
 102 prefix_ senf::ClientSocketHandle<Policy>::ClientSocketHandle()
 103 {}
 104
 105 #ifndef DOXYGEN
 106 template <class Policy>
 107 template <class OtherPolicy>
 108 prefix_ senf::ClientSocketHandle<Policy>::
 109 ClientSocketHandle(ClientSocketHandle<OtherPolicy> other,
 110                    typename SocketHandle<Policy>::template IsCompatible<OtherPolicy>::type *)
 111     : SocketHandle<Policy>(other,true)
 112 {}
 113 #else
 114 template <class Policy>
 115 template <class OtherPolicy>
 116 prefix_ senf::ClientSocketHandle<Policy>::
 117 ClientSocketHandle(ClientSocketHandle<OtherPolicy> other)
 118 {}
 119 #endif
 120
 121 template <class Policy>
 122 prefix_ senf::ClientSocketHandle<Policy>::ClientSocketHandle(FileHandle other, bool isChecked)
 123     : SocketHandle<Policy>(other, isChecked)
 124 {}
 125
 126 template <class Policy>
 127 prefix_
 128 senf::ClientSocketHandle<Policy>::ClientSocketHandle(std::auto_ptr<SocketProtocol> protocol,
 129                                                      int fd)
 130     : SocketHandle<Policy>(protocol,false)
 131 {
 132     this->body().fd(fd);
 133 }
 134
 135 #ifndef DOXYGEN
 136 template <class Policy>
 137 template <class OtherPolicy>
 138 prefix_ typename senf::SocketHandle<Policy>::template IsCompatible<OtherPolicy>::type const &
 139 senf::ClientSocketHandle<Policy>::operator=(ClientSocketHandle<OtherPolicy> other)
 140 {
 141     assign(other);
 142     return *this;
 143 }
 144 #else
 145 template <class Policy>
 146 template <class OtherPolicy>
 147 prefix_ OtherPolicy const &
 148 senf::ClientSocketHandle<Policy>::operator=(ClientSocketHandle<OtherPolicy> other)
 149 {}
 150 #endif
 151
 152 ////////////////////////////////////////
 153 // reading and writing
 154
 155 // senf::ClientSocketHandle<Policy>::read
 156
 157 #ifndef DOXYGEN
 158 template <class Policy>
 159 template <class ForwardWritableRange>
 160 prefix_ typename boost::range_iterator<ForwardWritableRange>::type
 161 senf::ClientSocketHandle<Policy>::
 162 read(ForwardWritableRange const & range,
 163      typename boost::disable_if< boost::is_convertible<ForwardWritableRange,unsigned> >::type *)
 164 {
 165     return detail::ReadRange<
 166         ClientSocketHandle<Policy>,
 167         ForwardWritableRange const,
 168         contiguous_storage_iterator<
 169             typename boost::range_iterator<ForwardWritableRange>::type
 170         >::value && sizeof(typename boost::range_value<ForwardWritableRange>::type)==sizeof(char)
 171         >::read(*this, range);
 172 }
 173 #else
 174 template <class Policy>
 175 template <class ForwardWritableRange>
 176 prefix_ typename boost::range_iterator<ForwardWritableRange>::type
 177 senf::ClientSocketHandle<Policy>::
 178 read(ForwardWritableRange const & range)
 179 {}
 180 #endif
 181
 182 #ifndef DOXYGEN
 183 template <class Policy>
 184 template <class ForwardWritableRange>
 185 prefix_ typename boost::range_iterator<ForwardWritableRange>::type
 186 senf::ClientSocketHandle<Policy>::
 187 read(ForwardWritableRange & range,
 188      typename boost::disable_if< boost::is_convertible<ForwardWritableRange,unsigned> >::type *)
 189 {
 190     return detail::ReadRange<
 191         ClientSocketHandle<Policy>,
 192         ForwardWritableRange,
 193         contiguous_storage_iterator<
 194             typename boost::range_iterator<ForwardWritableRange>::type
 195         >::value && sizeof(typename boost::range_value<ForwardWritableRange>::type)==sizeof(char)
 196         >::read(*this, range);
 197 }
 198 #else
 199 template <class Policy>
 200 template <class ForwardWritableRange>
 201 prefix_ typename boost::range_iterator<ForwardWritableRange>::type
 202 senf::ClientSocketHandle<Policy>::
 203 read(ForwardWritableRange & range)
 204 {}
 205 #endif
 206
 207 template <class Policy>
 208 prefix_ char * senf::ClientSocketHandle<Policy>::read(char * start, char * end)
 209 {
 210     return start + Policy::ReadPolicy::read(*this, start, end-start);
 211 }
 212
 213 // senf::ClientSocketHandle<Policy>::readfrom
 214
 215 template <class Policy>
 216 template <class ForwardWritableRange>
 217 prefix_ typename boost::range_iterator<ForwardWritableRange const>::type
 218 senf::ClientSocketHandle<Policy>::readfrom(ForwardWritableRange const & range, Address & from)
 219 {
 220     return detail::ReadRange<
 221         ClientSocketHandle<Policy>,
 222         ForwardWritableRange const,
 223         contiguous_storage_iterator<
 224             typename boost::range_iterator<ForwardWritableRange>::type
 225         >::value && sizeof(typename boost::range_value<ForwardWritableRange>::type)==sizeof(char)
 226         >::readfrom(*this, range, from);
 227 }
 228
 229 template <class Policy>
 230 template <class ForwardWritableRange>
 231 prefix_ typename boost::range_iterator<ForwardWritableRange>::type
 232 senf::ClientSocketHandle<Policy>::readfrom(ForwardWritableRange & range, Address & from)
 233 {
 234     return detail::ReadRange<
 235         ClientSocketHandle<Policy>,
 236         ForwardWritableRange,
 237         contiguous_storage_iterator<
 238             typename boost::range_iterator<ForwardWritableRange>::type
 239         >::value && sizeof(typename boost::range_value<ForwardWritableRange>::type)==sizeof(char)
 240         >::readfrom(*this, range, from);
 241 }
 242
 243 template <class Policy>
 244 prefix_ char * senf::ClientSocketHandle<Policy>::readfrom(char * start, char * end,
 245                                                           Address & from)
 246 {
 247     return start + Policy::ReadPolicy::readfrom(*this, start, end-start, from);
 248 }
 249
 250 // senf::ClientSocketHandle<Policy>::write
 251
 252 template <class Policy>
 253 template <class ForwardReadableRange>
 254 prefix_ typename boost::range_const_iterator<ForwardReadableRange const>::type
 255 senf::ClientSocketHandle<Policy>::write(ForwardReadableRange const & range)
 256 {
 257     return detail::WriteRange<
 258         ClientSocketHandle<Policy>,
 259         ForwardReadableRange const,
 260         contiguous_storage_iterator<
 261             typename boost::range_iterator<ForwardReadableRange>::type
 262         >::value && sizeof(typename boost::range_value<ForwardReadableRange>::type)==sizeof(char)
 263         >::write(*this, range);
 264 }
 265
 266 template <class Policy>
 267 prefix_ char const * senf::ClientSocketHandle<Policy>::write(char const * start, char const * end)
 268 {
 269     return start + Policy::WritePolicy::write(*this, start, end-start);
 270 }
 271
 272 // senf::ClientSocketHandle<Policy>::writeto
 273
 274 template <class Policy>
 275 template <class ForwardReadableRange>
 276 prefix_ typename boost::range_const_iterator<ForwardReadableRange const>::type
 277 senf::ClientSocketHandle<Policy>::writeto(AddressParam addr, ForwardReadableRange const & range)
 278 {
 279     return detail::WriteRange<
 280         ClientSocketHandle<Policy>,
 281         ForwardReadableRange const,
 282         contiguous_storage_iterator<
 283             typename boost::range_iterator<ForwardReadableRange>::type
 284         >::value && sizeof(typename boost::range_value<ForwardReadableRange>::type)==sizeof(char)
 285         >::writeto(*this, range, addr);
 286 }
 287
 288 template <class Policy>
 289 prefix_ char const * senf::ClientSocketHandle<Policy>::writeto(AddressParam addr,
 290                                                                char const * start,
 291                                                                char const * end)
 292 {
 293     return start + Policy::WritePolicy::writeto(*this, addr, start, end-start);
 294 }
 295
 296 ////////////////////////////////////////
 297 // addressing
 298
 299 // senf::ClientSocketHandle<Policy>::peer
 300
 301 template <class Policy>
 302 prefix_ typename Policy::AddressingPolicy::Address
 303 senf::ClientSocketHandle<Policy>::peer()
 304 {
 305     typename Policy::AddressingPolicy::Address addr;
 306     this->peer(addr);
 307     return addr;
 308 }
 309
 310 template <class Policy>
 311 prefix_ void senf::ClientSocketHandle<Policy>::
 312 peer(typename Policy::AddressingPolicy::Address & addr)
 313 {
 314     Policy::AddressingPolicy::peer(*this,addr);
 315 }
 316
 317 // senf::ClientSocketHandle<Policy>::local
 318
 319 template <class Policy>
 320 prefix_ typename Policy::AddressingPolicy::Address
 321 senf::ClientSocketHandle<Policy>::local()
 322 {
 323     typename Policy::AddressingPolicy::Address addr;
 324     this->local(addr);
 325     return addr;
 326 }
 327
 328 template <class Policy>
 329 prefix_ void senf::ClientSocketHandle<Policy>::
 330 local(typename Policy::AddressingPolicy::Address & addr)
 331 {
 332     Policy::AddressingPolicy::local(*this,addr);
 333 }
 334
 335 // senf::ClientSocketHandle<Policy>::connect
 336
 337 template <class Policy>
 338 prefix_ void senf::ClientSocketHandle<Policy>::connect(AddressParam addr)
 339 {
 340     Policy::AddressingPolicy::connect(*this,addr);
 341 }
 342
 343 // senf::ClientSocketHandle<Policy>::bind
 344
 345 template <class Policy>
 346 prefix_ void senf::ClientSocketHandle<Policy>::
 347 bind(typename boost::call_traits<typename Policy::AddressingPolicy::Address>::param_type addr)
 348 {
 349     Policy::AddressingPolicy::bind(*this,addr);
 350 }
 351
 352 ////////////////////////////////////////
 353 // Buffering
 354
 355 // senf::ClientSocketHandle<Policy>::rcvbuf
 356
 357 template <class Policy>
 358 prefix_ unsigned senf::ClientSocketHandle<Policy>::rcvbuf()
 359 {
 360     return Policy::BufferingPolicy::rcvbuf(*this);
 361 }
 362
 363 template <class Policy>
 364 prefix_ void senf::ClientSocketHandle<Policy>::rcvbuf(unsigned size)
 365 {
 366     Policy::BufferingPolicy::rcvbuf(*this,size);
 367 }
 368
 369 // senf::ClientSocketHandle<Policy>::sndbuf
 370
 371 template <class Policy>
 372 prefix_ unsigned senf::ClientSocketHandle<Policy>::sndbuf()
 373 {
 374     return Policy::BufferingPolicy::sndbuf(*this);
 375 }
 376
 377 template <class Policy>
 378 prefix_ void senf::ClientSocketHandle<Policy>::sndbuf(unsigned size)
 379 {
 380     Policy::BufferingPolicy::sndbuf(*this,size);
 381 }
 382
 383 ////////////////////////////////////////
 384 // Casting
 385
 386 template <class Policy>
 387 prefix_ senf::ClientSocketHandle<Policy>
 388 senf::ClientSocketHandle<Policy>::cast_static(FileHandle handle)
 389 {
 390     return ClientSocketHandle(handle, true);
 391 }
 392
 393 template <class Policy>
 394 prefix_ senf::ClientSocketHandle<Policy>
 395 senf::ClientSocketHandle<Policy>::cast_dynamic(FileHandle handle)
 396 {
 397     SocketHandle<Policy> h (SocketHandle<Policy>::cast_dynamic(handle));
 398     if (static_cast<SocketBody&>(FileHandle::body(h)).isServer())
 399         throw std::bad_cast();
 400     return cast_static(handle);
 401 }
 402
 403 ////////////////////////////////////////
 404 // State information
 405
 406 template <class Policy>
 407 prefix_ void senf::ClientSocketHandle<Policy>::state(SocketStateMap & map, unsigned lod)
 408 {
 409     map["handle"] = prettyName(typeid(*this));
 410     this->body().state(map,lod);
 411 }
 412
 413 template <class Policy>
 414 prefix_ std::string senf::ClientSocketHandle<Policy>::dumpState(unsigned lod)
 415 {
 416     SocketStateMap map;
 417     state(map,lod);
 418     return detail::dumpState(map);
 419 }
 420
 421 ///////////////////////////////cti.e///////////////////////////////////////
 422 #undef prefix_
 423
 424 \f
 425 // Local Variables:
 426 // mode: c++
 427 // fill-column: 100
 428 // c-file-style: "senf"
 429 // indent-tabs-mode: nil
 430 // ispell-local-dictionary: "american"
 431 // compile-command: "scons -u test"
 432 // comment-column: 40
 433 // End: