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 // senf::detail::ReadRange<Policy,ForwardWritableRange,true>::read
  39
  40 template <class Handle, class ForwardWritableRange>
  41 prefix_ typename boost::range_iterator<ForwardWritableRange>::type
  42 senf::detail::ReadRange<Handle,ForwardWritableRange,true>::read(Handle & handle,
  43                                                                 ForwardWritableRange & range)
  44 {
  45     typename boost::range_iterator<ForwardWritableRange>::type i (boost::begin(range));
  46     char * ic (reinterpret_cast<char*>(storage_iterator(i)));
  47     return i + (handle.read( ic,
  48                              reinterpret_cast<char*>(storage_iterator(boost::end(range))) )
  49                 - ic);
  50 }
  51
  52 // senf::detail::ReadRange<Policy,ForwardWritableRange,true>::readfrom
  53
  54 template <class Handle, class ForwardWritableRange>
  55 prefix_ typename boost::range_iterator<ForwardWritableRange>::type
  56 senf::detail::ReadRange<Handle,ForwardWritableRange,true>::
  57 readfrom(Handle & handle, ForwardWritableRange & range, typename Handle::Address & addr)
  58 {
  59     typename boost::range_iterator<ForwardWritableRange>::type i (boost::begin(range));
  60     char * ic (reinterpret_cast<char*>(storage_iterator(i)));
  61     return i + (handle.readfrom( ic,
  62                                  reinterpret_cast<char*>(storage_iterator(boost::end(range))),
  63                                  addr )
  64                 - ic);
  65 }
  66
  67 ///////////////////////////////////////////////////////////////////////////
  68 // senf::ClientSocketHandle<Policy>
  69
  70 ////////////////////////////////////////
  71 // structors
  72
  73 template <class Policy>
  74 template <class OtherPolicy>
  75 prefix_ senf::ClientSocketHandle<Policy>::
  76 ClientSocketHandle(ClientSocketHandle<OtherPolicy> other,
  77                    typename SocketHandle<Policy>::template IsCompatible<OtherPolicy>::type *)
  78     : SocketHandle<Policy>(other,true)
  79 {}
  80
  81 template <class Policy>
  82 prefix_ senf::ClientSocketHandle<Policy>::ClientSocketHandle(FileHandle other, bool isChecked)
  83     : SocketHandle<Policy>(other, isChecked)
  84 {}
  85
  86 template <class Policy>
  87 prefix_
  88 senf::ClientSocketHandle<Policy>::ClientSocketHandle(std::auto_ptr<SocketProtocol> protocol,
  89                                                      int fd)
  90     : SocketHandle<Policy>(protocol,false)
  91 {
  92     this->body().fd(fd);
  93 }
  94
  95 template <class Policy>
  96 template <class OtherPolicy>
  97 prefix_ typename senf::SocketHandle<Policy>::template IsCompatible<OtherPolicy>::type const &
  98 senf::ClientSocketHandle<Policy>::operator=(ClientSocketHandle<OtherPolicy> other)
  99 {
 100     assign(other);
 101     return *this;
 102 }
 103
 104 ////////////////////////////////////////
 105 // reading and writing
 106
 107 // senf::ClientSocketHandle<Policy>::read
 108
 109 template <class Policy>
 110 template <class ForwardWritableRange>
 111 prefix_ typename boost::range_iterator<ForwardWritableRange>::type
 112 senf::ClientSocketHandle<Policy>::read(ForwardWritableRange const & range)
 113 {
 114     return detail::ReadRange<
 115         ClientSocketHandle<Policy>,
 116         ForwardWritableRange const,
 117         contiguous_storage_iterator<
 118             typename boost::range_iterator<ForwardWritableRange>::type
 119         >::value && sizeof(typename boost::range_value<ForwardWritableRange>::type)==sizeof(char)
 120         >::read(*this, range);
 121 }
 122
 123 template <class Policy>
 124 template <class ForwardWritableRange>
 125 prefix_ typename boost::range_iterator<ForwardWritableRange>::type
 126 senf::ClientSocketHandle<Policy>::read(ForwardWritableRange & range)
 127 {
 128     return detail::ReadRange<
 129         ClientSocketHandle<Policy>,
 130         ForwardWritableRange,
 131         contiguous_storage_iterator<
 132             typename boost::range_iterator<ForwardWritableRange>::type
 133         >::value && sizeof(typename boost::range_value<ForwardWritableRange>::type)==sizeof(char)
 134         >::read(*this, range);
 135 }
 136
 137 template <class Policy>
 138 prefix_ char * senf::ClientSocketHandle<Policy>::read(char * start, char * end)
 139 {
 140     return start + Policy::ReadPolicy::read(*this, start, end-start);
 141 }
 142
 143 // senf::ClientSocketHandle<Policy>::readfrom
 144
 145 template <class Policy>
 146 template <class ForwardWritableRange>
 147 prefix_ typename boost::range_iterator<ForwardWritableRange>::type
 148 senf::ClientSocketHandle<Policy>::readfrom(ForwardWritableRange const & range, Address & from)
 149 {
 150     return detail::ReadRange<
 151         ClientSocketHandle<Policy>,
 152         ForwardWritableRange const,
 153         contiguous_storage_iterator<
 154             typename boost::range_iterator<ForwardWritableRange>::type
 155         >::value && sizeof(typename boost::range_value<ForwardWritableRange>::type)==sizeof(char)
 156         >::readfrom(*this, range, from);
 157 }
 158
 159 template <class Policy>
 160 template <class ForwardWritableRange>
 161 prefix_ typename boost::range_iterator<ForwardWritableRange>::type
 162 senf::ClientSocketHandle<Policy>::readfrom(ForwardWritableRange & range, Address & from)
 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         >::readfrom(*this, range, from);
 171 }
 172
 173 template <class Policy>
 174 prefix_ char * senf::ClientSocketHandle<Policy>::readfrom(char * start, char * end,
 175                                                           Address & from)
 176 {
 177     return start + Policy::ReadPolicy::readfrom(*this, start, end-start, from);
 178 }
 179
 180 // senf::ClientSocketHandle<Policy>::write
 181
 182 template <class Policy>
 183 prefix_ unsigned senf::ClientSocketHandle<Policy>::write(char const * buffer,
 184                                                                 unsigned size)
 185 {
 186     return Policy::WritePolicy::write(*this, buffer, size);
 187 }
 188
 189 // senf::ClientSocketHandle<Policy>::writeto
 190
 191 template <class Policy>
 192 prefix_ unsigned senf::ClientSocketHandle<Policy>::
 193 writeto(typename boost::call_traits<typename Policy::AddressingPolicy::Address>::param_type addr,
 194         std::string const & data)
 195 {
 196     return this->writeto(addr, data.data(), data.size());
 197 }
 198
 199 template <class Policy>
 200 prefix_ unsigned senf::ClientSocketHandle<Policy>::
 201 writeto(typename boost::call_traits<typename Policy::AddressingPolicy::Address>::param_type addr,
 202         char const * buffer, unsigned size)
 203 {
 204     return Policy::WritePolicy::writeto(*this, addr, buffer, size);
 205 }
 206
 207 ////////////////////////////////////////
 208 // addressing
 209
 210 // senf::ClientSocketHandle<Policy>::peer
 211
 212 template <class Policy>
 213 prefix_ typename Policy::AddressingPolicy::Address
 214 senf::ClientSocketHandle<Policy>::peer()
 215 {
 216     typename Policy::AddressingPolicy::Address addr;
 217     this->peer(addr);
 218     return addr;
 219 }
 220
 221 template <class Policy>
 222 prefix_ void senf::ClientSocketHandle<Policy>::
 223 peer(typename Policy::AddressingPolicy::Address & addr)
 224 {
 225     Policy::AddressingPolicy::peer(*this,addr);
 226 }
 227
 228 // senf::ClientSocketHandle<Policy>::local
 229
 230 template <class Policy>
 231 prefix_ typename Policy::AddressingPolicy::Address
 232 senf::ClientSocketHandle<Policy>::local()
 233 {
 234     typename Policy::AddressingPolicy::Address addr;
 235     this->local(addr);
 236     return addr;
 237 }
 238
 239 template <class Policy>
 240 prefix_ void senf::ClientSocketHandle<Policy>::
 241 local(typename Policy::AddressingPolicy::Address & addr)
 242 {
 243     Policy::AddressingPolicy::local(*this,addr);
 244 }
 245
 246 // senf::ClientSocketHandle<Policy>::connect
 247
 248 template <class Policy>
 249 prefix_ void senf::ClientSocketHandle<Policy>::connect(AddressParam addr)
 250 {
 251     Policy::AddressingPolicy::connect(*this,addr);
 252 }
 253
 254 // senf::ClientSocketHandle<Policy>::bind
 255
 256 template <class Policy>
 257 prefix_ void senf::ClientSocketHandle<Policy>::
 258 bind(typename boost::call_traits<typename Policy::AddressingPolicy::Address>::param_type addr)
 259 {
 260     Policy::AddressingPolicy::bind(*this,addr);
 261 }
 262
 263 ////////////////////////////////////////
 264 // Buffering
 265
 266 // senf::ClientSocketHandle<Policy>::rcvbuf
 267
 268 template <class Policy>
 269 prefix_ unsigned senf::ClientSocketHandle<Policy>::rcvbuf()
 270 {
 271     return Policy::BufferingPolicy::rcvbuf(*this);
 272 }
 273
 274 template <class Policy>
 275 prefix_ void senf::ClientSocketHandle<Policy>::rcvbuf(unsigned size)
 276 {
 277     Policy::BufferingPolicy::rcvbuf(*this,size);
 278 }
 279
 280 // senf::ClientSocketHandle<Policy>::sndbuf
 281
 282 template <class Policy>
 283 prefix_ unsigned senf::ClientSocketHandle<Policy>::sndbuf()
 284 {
 285     return Policy::BufferingPolicy::sndbuf(*this);
 286 }
 287
 288 template <class Policy>
 289 prefix_ void senf::ClientSocketHandle<Policy>::sndbuf(unsigned size)
 290 {
 291     Policy::BufferingPolicy::sndbuf(*this,size);
 292 }
 293
 294 ////////////////////////////////////////
 295 // Casting
 296
 297 template <class Policy>
 298 prefix_ senf::ClientSocketHandle<Policy>
 299 senf::ClientSocketHandle<Policy>::cast_static(FileHandle handle)
 300 {
 301     return ClientSocketHandle(handle, true);
 302 }
 303
 304 template <class Policy>
 305 prefix_ senf::ClientSocketHandle<Policy>
 306 senf::ClientSocketHandle<Policy>::cast_dynamic(FileHandle handle)
 307 {
 308     SocketHandle<Policy> h (SocketHandle<Policy>::cast_dynamic(handle));
 309     if (static_cast<SocketBody&>(FileHandle::body(h)).isServer())
 310         throw std::bad_cast();
 311     return cast_static(handle);
 312 }
 313
 314 ////////////////////////////////////////
 315 // State information
 316
 317 template <class Policy>
 318 prefix_ void senf::ClientSocketHandle<Policy>::state(SocketStateMap & map, unsigned lod)
 319 {
 320     map["handle"] = prettyName(typeid(*this));
 321     this->body().state(map,lod);
 322 }
 323
 324 template <class Policy>
 325 prefix_ std::string senf::ClientSocketHandle<Policy>::dumpState(unsigned lod)
 326 {
 327     SocketStateMap map;
 328     state(map,lod);
 329     return detail::dumpState(map);
 330 }
 331
 332 ///////////////////////////////cti.e///////////////////////////////////////
 333 #undef prefix_
 334
 335 \f
 336 // Local Variables:
 337 // mode: c++
 338 // fill-column: 100
 339 // c-file-style: "senf"
 340 // indent-tabs-mode: nil
 341 // ispell-local-dictionary: "american"
 342 // End: