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