Socket/ClientSocketHandle.ct

   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 non-inline template implementation
  25  */
  26
  27 #include "ClientSocketHandle.ih"
  28
  29 // Custom includes
  30 #include <algorithm>
  31 #include "Utils/Buffer.hh"
  32
  33 #define prefix_
  34 ///////////////////////////////ct.p////////////////////////////////////////
  35
  36 ///////////////////////////////////////////////////////////////////////////
  37 // senf::detail::ReadRange<Handle,ForwardWritableRange,IsContiguous>
  38
  39 template <class Handle, class ForwardWritableRange, bool IsContiguous>
  40 prefix_ typename boost::range_iterator<ForwardWritableRange>::type
  41 senf::detail::ReadRange<Handle,ForwardWritableRange,IsContiguous>::
  42 read(Handle & handle, ForwardWritableRange & range)
  43 {
  44     typename boost::range_size<ForwardWritableRange>::type nread (boost::size(range));
  45     SENF_SCOPED_BUFFER(char, buffer, nread);
  46     return std::copy(buffer, handle.read(buffer,buffer+nread), boost::begin(range));
  47 }
  48
  49 template <class Handle, class ForwardWritableRange, bool IsContiguous>
  50 prefix_ typename boost::range_iterator<ForwardWritableRange>::type
  51 senf::detail::ReadRange<Handle,ForwardWritableRange,IsContiguous>::
  52 readfrom(Handle & handle, ForwardWritableRange & range, typename Handle::Address & addr)
  53 {
  54     typename boost::range_size<ForwardWritableRange>::type nread (boost::size(range));
  55     SENF_SCOPED_BUFFER(char, buffer, nread);
  56     return std::copy(buffer, handle.readfrom(buffer,buffer+nread,addr), boost::begin(range));
  57 }
  58
  59 ///////////////////////////////////////////////////////////////////////////
  60 // senf::detail::WriteRange<Handle,ForwardReadableRange,IsContiguous>
  61
  62 template <class Handle, class ForwardReadableRange, bool IsContiguous>
  63 prefix_ typename boost::range_iterator<ForwardReadableRange>::type
  64 senf::detail::WriteRange<Handle,ForwardReadableRange,IsContiguous>::
  65 write(Handle & handle, ForwardReadableRange & range)
  66 {
  67     typename boost::range_size<ForwardReadableRange>::type nwrite (boost::size(range));
  68     SENF_SCOPED_BUFFER(char, buffer, nwrite);
  69     std::copy(boost::begin(range), boost::end(range), buffer);
  70     return handle.write(std::make_pair(buffer, buffer+nwrite));
  71 }
  72
  73 template <class Handle, class ForwardReadableRange, bool IsContiguous>
  74 prefix_ typename boost::range_iterator<ForwardReadableRange>::type
  75 senf::detail::WriteRange<Handle,ForwardReadableRange,IsContiguous>::
  76 writeto(Handle & handle, ForwardReadableRange & range, typename Handle::Address const & addr)
  77 {
  78     typename boost::range_size<ForwardReadableRange>::type nwrite (boost::size(range));
  79     SENF_SCOPED_BUFFER(char, buffer, nwrite);
  80     std::copy(boost::begin(range), boost::end(range), buffer);
  81     return handle.writeto(std::make_pair(buffer, buffer+nwrite), addr);
  82 }
  83
  84 ///////////////////////////////////////////////////////////////////////////
  85 // senf::ClientSocketHandle<Policy>
  86
  87 ////////////////////////////////////////
  88 // reading and writing
  89
  90 // senf::ClientSocketHandle<Policy>::read
  91
  92 template <class Policy>
  93 prefix_ std::string senf::ClientSocketHandle<Policy>::read(unsigned limit)
  94 {
  95     std::string rv;
  96     this->read(rv,limit);
  97     return rv;
  98 }
  99
 100 template <class Policy>
 101 template <class Sequence>
 102 prefix_ void senf::ClientSocketHandle<Policy>::read(Sequence & container, unsigned limit)
 103 {
 104     unsigned nread (available());
 105     if (limit>0 && nread>limit)
 106         nread = limit;
 107     container.resize(nread);
 108     container.erase(read( std::make_pair(container.begin(), container.end()) ),
 109                     container.end());
 110 }
 111
 112 // senf::ClientSocketHandle<Policy>::readfrom
 113
 114 template <class Policy>
 115 prefix_ std::pair<std::string, typename Policy::AddressingPolicy::Address>
 116 senf::ClientSocketHandle<Policy>::readfrom(unsigned limit)
 117 {
 118     std::string rv;
 119     typename Policy::AddressingPolicy::Address addr;
 120     this->readfrom(rv,addr,limit);
 121     return std::make_pair(rv,addr);
 122 }
 123
 124 template <class Policy>
 125 template <class Sequence>
 126 prefix_ void senf::ClientSocketHandle<Policy>::readfrom(Sequence & container, Address & from,
 127                                                         unsigned limit)
 128 {
 129     unsigned nread (available());
 130     if (limit>0 && nread>limit)
 131         nread = limit;
 132     container.resize(nread);
 133     container.erase(readfrom( std::make_pair(container.begin(), container.end()), from ),
 134                     container.end());
 135 }
 136
 137 ////////////////////////////////////////
 138 // private members
 139
 140 // senf::ClientSocketHandle<Policy>::available
 141
 142 template <class Policy>
 143 prefix_ unsigned senf::ClientSocketHandle<Policy>::available()
 144 {
 145     unsigned nread = this->protocol().available();
 146     if (nread == 0 && this->blocking()) {
 147         // We have to block explicitly here so we can return the
 148         // number of bytes available explicitly. If no more date can
 149         // be expected to arive (i.e. the other end has closed the
 150         // connection), the socket will always be in the readable
 151         // state. This is the only case when available() will return
 152         // 0.
 153         this->waitReadable();
 154         nread = this->protocol().available();
 155     }
 156     return nread;
 157 }
 158
 159 ///////////////////////////////ct.e////////////////////////////////////////
 160 #undef prefix_
 161
 162 \f
 163 // Local Variables:
 164 // mode: c++
 165 // fill-column: 100
 166 // c-file-style: "senf"
 167 // indent-tabs-mode: nil
 168 // ispell-local-dictionary: "american"
 169 // compile-command: "scons -u test"
 170 // comment-column: 40
 171 // End: