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