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