Socket/ClientSocketHandle.cti

   1 // $Id$
   2 //
   3 // Copyright (C) 2006
   4 // Fraunhofer Institute for Open Communication Systems (FOKUS)
   5 // Competence Center NETwork research (NET), St. Augustin, GERMANY
   6 //     Stefan Bund <g0dil@berlios.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 i
  72         (boost::const_begin(range));
  73     char const * const ic (reinterpret_cast<char const *>(storage_iterator(i)));
  74     std::advance(i, handle.write(ic,
  75                                  reinterpret_cast<char const *>(
  76                                      storage_iterator(boost::const_end(range)))) - ic);
  77     return i;
  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 i
  86         (boost::const_begin(range));
  87     char const * const ic (reinterpret_cast<char const *>(storage_iterator(i)));
  88     std::advance(i, handle.writeto(addr, ic,
  89                                    reinterpret_cast<char const *>(
  90                                        storage_iterator(boost::const_end(range)))) - ic);
  91     return i;
  92 }
  93
  94 ///////////////////////////////////////////////////////////////////////////
  95 // senf::ClientSocketHandle<Policy>
  96
  97 ////////////////////////////////////////
  98 // structors
  99
 100 template <class Policy>
 101 prefix_ senf::ClientSocketHandle<Policy>::ClientSocketHandle()
 102 {}
 103
 104 #ifndef DOXYGEN
 105 template <class Policy>
 106 template <class OtherPolicy>
 107 prefix_ senf::ClientSocketHandle<Policy>::
 108 ClientSocketHandle(ClientSocketHandle<OtherPolicy> other,
 109                    typename SocketHandle<Policy>::template IsCompatible<OtherPolicy>::type *)
 110     : SocketHandle<Policy>(other,true)
 111 {}
 112 #else
 113 template <class Policy>
 114 template <class OtherPolicy>
 115 prefix_ senf::ClientSocketHandle<Policy>::
 116 ClientSocketHandle(ClientSocketHandle<OtherPolicy> other)
 117 {}
 118 #endif
 119
 120 template <class Policy>
 121 prefix_ senf::ClientSocketHandle<Policy>::ClientSocketHandle(FileHandle other, bool isChecked)
 122     : SocketHandle<Policy>(other, isChecked)
 123 {}
 124
 125 template <class Policy>
 126 prefix_
 127 senf::ClientSocketHandle<Policy>::ClientSocketHandle(std::auto_ptr<SocketProtocol> protocol,
 128                                                      int fd)
 129     : SocketHandle<Policy>(protocol,false)
 130 {
 131     this->body().fd(fd);
 132 }
 133
 134 #ifndef DOXYGEN
 135 template <class Policy>
 136 template <class OtherPolicy>
 137 prefix_ typename senf::SocketHandle<Policy>::template IsCompatible<OtherPolicy>::type const &
 138 senf::ClientSocketHandle<Policy>::operator=(ClientSocketHandle<OtherPolicy> other)
 139 {
 140     assign(other);
 141     return *this;
 142 }
 143 #else
 144 template <class Policy>
 145 template <class OtherPolicy>
 146 prefix_ OtherPolicy const &
 147 senf::ClientSocketHandle<Policy>::operator=(ClientSocketHandle<OtherPolicy> other)
 148 {}
 149 #endif
 150
 151 ////////////////////////////////////////
 152 // reading and writing
 153
 154 // senf::ClientSocketHandle<Policy>::read
 155
 156 #ifndef DOXYGEN
 157 template <class Policy>
 158 template <class ForwardWritableRange>
 159 prefix_ typename boost::range_iterator<ForwardWritableRange>::type
 160 senf::ClientSocketHandle<Policy>::
 161 read(ForwardWritableRange const & range,
 162      typename boost::disable_if< boost::is_convertible<ForwardWritableRange,unsigned> >::type *)
 163 {
 164     return detail::ReadRange<
 165         ClientSocketHandle<Policy>,
 166         ForwardWritableRange const,
 167         contiguous_storage_iterator<
 168             typename boost::range_iterator<ForwardWritableRange>::type
 169         >::value && sizeof(typename boost::range_value<ForwardWritableRange>::type)==sizeof(char)
 170         >::read(*this, range);
 171 }
 172 #else
 173 template <class Policy>
 174 template <class ForwardWritableRange>
 175 prefix_ typename boost::range_iterator<ForwardWritableRange>::type
 176 senf::ClientSocketHandle<Policy>::
 177 read(ForwardWritableRange const & range)
 178 {}
 179 #endif
 180
 181 #ifndef DOXYGEN
 182 template <class Policy>
 183 template <class ForwardWritableRange>
 184 prefix_ typename boost::range_iterator<ForwardWritableRange>::type
 185 senf::ClientSocketHandle<Policy>::
 186 read(ForwardWritableRange & range,
 187      typename boost::disable_if< boost::is_convertible<ForwardWritableRange,unsigned> >::type *)
 188 {
 189     return detail::ReadRange<
 190         ClientSocketHandle<Policy>,
 191         ForwardWritableRange,
 192         contiguous_storage_iterator<
 193             typename boost::range_iterator<ForwardWritableRange>::type
 194         >::value && sizeof(typename boost::range_value<ForwardWritableRange>::type)==sizeof(char)
 195         >::read(*this, range);
 196 }
 197 #else
 198 template <class Policy>
 199 template <class ForwardWritableRange>
 200 prefix_ typename boost::range_iterator<ForwardWritableRange>::type
 201 senf::ClientSocketHandle<Policy>::
 202 read(ForwardWritableRange & range)
 203 {}
 204 #endif
 205
 206 template <class Policy>
 207 prefix_ char * senf::ClientSocketHandle<Policy>::read(char * start, char * end)
 208 {
 209     return start + Policy::ReadPolicy::read(*this, start, end-start);
 210 }
 211
 212 // senf::ClientSocketHandle<Policy>::readfrom
 213
 214 template <class Policy>
 215 template <class ForwardWritableRange>
 216 prefix_ typename boost::range_iterator<ForwardWritableRange const>::type
 217 senf::ClientSocketHandle<Policy>::readfrom(ForwardWritableRange const & range, Address & from)
 218 {
 219     return detail::ReadRange<
 220         ClientSocketHandle<Policy>,
 221         ForwardWritableRange const,
 222         contiguous_storage_iterator<
 223             typename boost::range_iterator<ForwardWritableRange>::type
 224         >::value && sizeof(typename boost::range_value<ForwardWritableRange>::type)==sizeof(char)
 225         >::readfrom(*this, range, from);
 226 }
 227
 228 template <class Policy>
 229 template <class ForwardWritableRange>
 230 prefix_ typename boost::range_iterator<ForwardWritableRange>::type
 231 senf::ClientSocketHandle<Policy>::readfrom(ForwardWritableRange & range, Address & from)
 232 {
 233     return detail::ReadRange<
 234         ClientSocketHandle<Policy>,
 235         ForwardWritableRange,
 236         contiguous_storage_iterator<
 237             typename boost::range_iterator<ForwardWritableRange>::type
 238         >::value && sizeof(typename boost::range_value<ForwardWritableRange>::type)==sizeof(char)
 239         >::readfrom(*this, range, from);
 240 }
 241
 242 template <class Policy>
 243 prefix_ char * senf::ClientSocketHandle<Policy>::readfrom(char * start, char * end,
 244                                                           Address & from)
 245 {
 246     return start + Policy::ReadPolicy::readfrom(*this, start, end-start, from);
 247 }
 248
 249 // senf::ClientSocketHandle<Policy>::write
 250
 251 template <class Policy>
 252 template <class ForwardReadableRange>
 253 prefix_ typename boost::range_const_iterator<ForwardReadableRange const>::type
 254 senf::ClientSocketHandle<Policy>::write(ForwardReadableRange const & range)
 255 {
 256     return detail::WriteRange<
 257         ClientSocketHandle<Policy>,
 258         ForwardReadableRange const,
 259         contiguous_storage_iterator<
 260             typename boost::range_iterator<ForwardReadableRange>::type
 261         >::value && sizeof(typename boost::range_value<ForwardReadableRange>::type)==sizeof(char)
 262         >::write(*this, range);
 263 }
 264
 265 template <class Policy>
 266 prefix_ char const * senf::ClientSocketHandle<Policy>::write(char const * start, char const * end)
 267 {
 268     return start + Policy::WritePolicy::write(*this, start, end-start);
 269 }
 270
 271 // senf::ClientSocketHandle<Policy>::writeto
 272
 273 template <class Policy>
 274 template <class ForwardReadableRange>
 275 prefix_ typename boost::range_const_iterator<ForwardReadableRange const>::type
 276 senf::ClientSocketHandle<Policy>::writeto(AddressParam addr, ForwardReadableRange const & range)
 277 {
 278     return detail::WriteRange<
 279         ClientSocketHandle<Policy>,
 280         ForwardReadableRange const,
 281         contiguous_storage_iterator<
 282             typename boost::range_iterator<ForwardReadableRange>::type
 283         >::value && sizeof(typename boost::range_value<ForwardReadableRange>::type)==sizeof(char)
 284         >::writeto(*this, range, addr);
 285 }
 286
 287 template <class Policy>
 288 prefix_ char const * senf::ClientSocketHandle<Policy>::writeto(AddressParam addr,
 289                                                                char const * start,
 290                                                                char const * end)
 291 {
 292     return start + Policy::WritePolicy::writeto(*this, addr, start, end-start);
 293 }
 294
 295 ////////////////////////////////////////
 296 // addressing
 297
 298 // senf::ClientSocketHandle<Policy>::peer
 299
 300 template <class Policy>
 301 prefix_ typename Policy::AddressingPolicy::Address
 302 senf::ClientSocketHandle<Policy>::peer()
 303 {
 304     typename Policy::AddressingPolicy::Address addr;
 305     this->peer(addr);
 306     return addr;
 307 }
 308
 309 template <class Policy>
 310 prefix_ void senf::ClientSocketHandle<Policy>::
 311 peer(typename Policy::AddressingPolicy::Address & addr)
 312 {
 313     Policy::AddressingPolicy::peer(*this,addr);
 314 }
 315
 316 // senf::ClientSocketHandle<Policy>::local
 317
 318 template <class Policy>
 319 prefix_ typename Policy::AddressingPolicy::Address
 320 senf::ClientSocketHandle<Policy>::local()
 321 {
 322     typename Policy::AddressingPolicy::Address addr;
 323     this->local(addr);
 324     return addr;
 325 }
 326
 327 template <class Policy>
 328 prefix_ void senf::ClientSocketHandle<Policy>::
 329 local(typename Policy::AddressingPolicy::Address & addr)
 330 {
 331     Policy::AddressingPolicy::local(*this,addr);
 332 }
 333
 334 // senf::ClientSocketHandle<Policy>::connect
 335
 336 template <class Policy>
 337 prefix_ void senf::ClientSocketHandle<Policy>::connect(AddressParam addr)
 338 {
 339     Policy::AddressingPolicy::connect(*this,addr);
 340 }
 341
 342 // senf::ClientSocketHandle<Policy>::bind
 343
 344 template <class Policy>
 345 prefix_ void senf::ClientSocketHandle<Policy>::
 346 bind(typename boost::call_traits<typename Policy::AddressingPolicy::Address>::param_type addr)
 347 {
 348     Policy::AddressingPolicy::bind(*this,addr);
 349 }
 350
 351 ////////////////////////////////////////
 352 // Buffering
 353
 354 // senf::ClientSocketHandle<Policy>::rcvbuf
 355
 356 template <class Policy>
 357 prefix_ unsigned senf::ClientSocketHandle<Policy>::rcvbuf()
 358 {
 359     return Policy::BufferingPolicy::rcvbuf(*this);
 360 }
 361
 362 template <class Policy>
 363 prefix_ void senf::ClientSocketHandle<Policy>::rcvbuf(unsigned size)
 364 {
 365     Policy::BufferingPolicy::rcvbuf(*this,size);
 366 }
 367
 368 // senf::ClientSocketHandle<Policy>::sndbuf
 369
 370 template <class Policy>
 371 prefix_ unsigned senf::ClientSocketHandle<Policy>::sndbuf()
 372 {
 373     return Policy::BufferingPolicy::sndbuf(*this);
 374 }
 375
 376 template <class Policy>
 377 prefix_ void senf::ClientSocketHandle<Policy>::sndbuf(unsigned size)
 378 {
 379     Policy::BufferingPolicy::sndbuf(*this,size);
 380 }
 381
 382 ////////////////////////////////////////
 383 // Casting
 384
 385 template <class Policy>
 386 prefix_ senf::ClientSocketHandle<Policy>
 387 senf::ClientSocketHandle<Policy>::cast_static(FileHandle handle)
 388 {
 389     return ClientSocketHandle(handle, true);
 390 }
 391
 392 template <class Policy>
 393 prefix_ senf::ClientSocketHandle<Policy>
 394 senf::ClientSocketHandle<Policy>::cast_dynamic(FileHandle handle)
 395 {
 396     SocketHandle<Policy> h (SocketHandle<Policy>::cast_dynamic(handle));
 397     if (static_cast<SocketBody&>(FileHandle::body(h)).isServer())
 398         throw std::bad_cast();
 399     return cast_static(handle);
 400 }
 401
 402 ////////////////////////////////////////
 403 // State information
 404
 405 template <class Policy>
 406 prefix_ void senf::ClientSocketHandle<Policy>::state(SocketStateMap & map, unsigned lod)
 407 {
 408     map["handle"] = prettyName(typeid(*this));
 409     this->body().state(map,lod);
 410 }
 411
 412 template <class Policy>
 413 prefix_ std::string senf::ClientSocketHandle<Policy>::dumpState(unsigned lod)
 414 {
 415     SocketStateMap map;
 416     state(map,lod);
 417     return detail::dumpState(map);
 418 }
 419
 420 ///////////////////////////////cti.e///////////////////////////////////////
 421 #undef prefix_
 422
 423 \f
 424 // Local Variables:
 425 // mode: c++
 426 // fill-column: 100
 427 // c-file-style: "senf"
 428 // indent-tabs-mode: nil
 429 // ispell-local-dictionary: "american"
 430 // compile-command: "scons -u test"
 431 // comment-column: 40
 432 // End: