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 template <class Policy>
  36 template <class OtherPolicy>
  37 prefix_ senf::ClientSocketHandle<Policy>::
  38 ClientSocketHandle(ClientSocketHandle<OtherPolicy> other,
  39                    typename SocketHandle<Policy>::template IsCompatible<OtherPolicy>::type *)
  40     : SocketHandle<Policy>(other,true)
  41 {}
  42
  43 template <class Policy>
  44 prefix_ senf::ClientSocketHandle<Policy>::ClientSocketHandle(FileHandle other,
  45                                                                     bool isChecked)
  46     : SocketHandle<Policy>(other, isChecked)
  47 {}
  48
  49 template <class Policy>
  50 prefix_  senf::ClientSocketHandle<Policy>::
  51 ClientSocketHandle(std::auto_ptr<SocketProtocol> protocol, int fd)
  52     : SocketHandle<Policy>(protocol,false)
  53 {
  54     this->body().fd(fd);
  55 }
  56
  57 template <class Policy>
  58 template <class OtherPolicy>
  59 prefix_ typename senf::SocketHandle<Policy>::template IsCompatible<OtherPolicy>::type const &
  60 senf::ClientSocketHandle<Policy>::operator=(ClientSocketHandle<OtherPolicy> other)
  61 {
  62     assign(other);
  63     return *this;
  64 }
  65
  66 ///////////////////////////////////////////////////////////////////////////
  67
  68 ///////////////////////////////////////////////////////////////////////////
  69 // reading and writing
  70
  71 template <class Policy>
  72 prefix_ unsigned senf::ClientSocketHandle<Policy>::read(char * buffer,
  73                                                                      unsigned size)
  74 {
  75     return Policy::ReadPolicy::read(*this, buffer, size);
  76 }
  77
  78 template <class Policy>
  79 prefix_ unsigned senf::ClientSocketHandle<Policy>::
  80 readfrom(char * buffer, unsigned size, typename Policy::AddressingPolicy::Address & from)
  81 {
  82     return Policy::ReadPolicy::readfrom(*this, buffer, size, from);
  83 }
  84
  85 template <class Policy>
  86 prefix_ unsigned senf::ClientSocketHandle<Policy>::write(char const * buffer,
  87                                                                 unsigned size)
  88 {
  89     return Policy::WritePolicy::write(*this, buffer, size);
  90 }
  91
  92 template <class Policy>
  93 prefix_ unsigned senf::ClientSocketHandle<Policy>::
  94 writeto(typename boost::call_traits<typename Policy::AddressingPolicy::Address>::param_type addr,
  95         std::string const & data)
  96 {
  97     return this->writeto(addr, data.data(), data.size());
  98 }
  99
 100 template <class Policy>
 101 prefix_ unsigned senf::ClientSocketHandle<Policy>::
 102 writeto(typename boost::call_traits<typename Policy::AddressingPolicy::Address>::param_type addr,
 103         char const * buffer, unsigned size)
 104 {
 105     return Policy::WritePolicy::writeto(*this, addr, buffer, size);
 106 }
 107
 108 ///////////////////////////////////////////////////////////////////////////
 109 // addressing
 110
 111 template <class Policy>
 112 prefix_ typename Policy::AddressingPolicy::Address
 113 senf::ClientSocketHandle<Policy>::peer()
 114 {
 115     typename Policy::AddressingPolicy::Address addr;
 116     this->peer(addr);
 117     return addr;
 118 }
 119
 120 template <class Policy>
 121 prefix_ void senf::ClientSocketHandle<Policy>::
 122 peer(typename Policy::AddressingPolicy::Address & addr)
 123 {
 124     Policy::AddressingPolicy::peer(*this,addr);
 125 }
 126
 127 template <class Policy>
 128 prefix_ typename Policy::AddressingPolicy::Address
 129 senf::ClientSocketHandle<Policy>::local()
 130 {
 131     typename Policy::AddressingPolicy::Address addr;
 132     this->local(addr);
 133     return addr;
 134 }
 135
 136 template <class Policy>
 137 prefix_ void senf::ClientSocketHandle<Policy>::
 138 local(typename Policy::AddressingPolicy::Address & addr)
 139 {
 140     Policy::AddressingPolicy::local(*this,addr);
 141 }
 142
 143 template <class Policy>
 144 prefix_ void senf::ClientSocketHandle<Policy>::connect(AddressParam addr)
 145 {
 146     Policy::AddressingPolicy::connect(*this,addr);
 147 }
 148
 149 template <class Policy>
 150 prefix_ void senf::ClientSocketHandle<Policy>::
 151 bind(typename boost::call_traits<typename Policy::AddressingPolicy::Address>::param_type addr)
 152 {
 153     Policy::AddressingPolicy::bind(*this,addr);
 154 }
 155
 156 ///////////////////////////////////////////////////////////////////////////
 157 // Buffering
 158
 159 template <class Policy>
 160 prefix_ unsigned senf::ClientSocketHandle<Policy>::rcvbuf()
 161 {
 162     return Policy::BufferingPolicy::rcvbuf(*this);
 163 }
 164
 165 template <class Policy>
 166 prefix_ void senf::ClientSocketHandle<Policy>::rcvbuf(unsigned size)
 167 {
 168     Policy::BufferingPolicy::rcvbuf(*this,size);
 169 }
 170
 171 template <class Policy>
 172 prefix_ unsigned senf::ClientSocketHandle<Policy>::sndbuf()
 173 {
 174     return Policy::BufferingPolicy::sndbuf(*this);
 175 }
 176
 177 template <class Policy>
 178 prefix_ void senf::ClientSocketHandle<Policy>::sndbuf(unsigned size)
 179 {
 180     Policy::BufferingPolicy::sndbuf(*this,size);
 181 }
 182
 183 ///////////////////////////////////////////////////////////////////////////
 184
 185 template <class Policy>
 186 prefix_ senf::ClientSocketHandle<Policy>
 187 senf::ClientSocketHandle<Policy>::cast_static(FileHandle handle)
 188 {
 189     return ClientSocketHandle(handle, true);
 190 }
 191
 192 template <class Policy>
 193 prefix_ senf::ClientSocketHandle<Policy>
 194 senf::ClientSocketHandle<Policy>::cast_dynamic(FileHandle handle)
 195 {
 196     SocketHandle<Policy> h (SocketHandle<Policy>::cast_dynamic(handle));
 197     if (static_cast<SocketBody&>(FileHandle::body(h)).isServer())
 198         throw std::bad_cast();
 199     return cast_static(handle);
 200 }
 201
 202 template <class Policy>
 203 prefix_ void senf::ClientSocketHandle<Policy>::state(SocketStateMap & map, unsigned lod)
 204 {
 205     map["handle"] = prettyName(typeid(*this));
 206     this->body().state(map,lod);
 207 }
 208
 209 template <class Policy>
 210 prefix_ std::string senf::ClientSocketHandle<Policy>::dumpState(unsigned lod)
 211 {
 212     SocketStateMap map;
 213     state(map,lod);
 214     return detail::dumpState(map);
 215 }
 216
 217 ///////////////////////////////cti.e///////////////////////////////////////
 218 #undef prefix_
 219
 220 \f
 221 // Local Variables:
 222 // mode: c++
 223 // fill-column: 100
 224 // c-file-style: "senf"
 225 // indent-tabs-mode: nil
 226 // ispell-local-dictionary: "american"
 227 // End: