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