ClientSocketHandle.ct

Go to the documentation of this file.
00001 // $Id: ClientSocketHandle.ct 1742 2010-11-04 14:51:56Z g0dil $
00002 //
00003 // Copyright (C) 2006
00004 // Fraunhofer (FOKUS)
00005 // Competence Center NETwork research (NET), St. Augustin, GERMANY
00006 //     Stefan Bund <g0dil@berlios.de>
00007 //
00008 // This program is free software; you can redistribute it and/or modify
00009 // it under the terms of the GNU General Public License as published by
00010 // the Free Software Foundation; either version 2 of the License, or
00011 // (at your option) any later version.
00012 //
00013 // This program is distributed in the hope that it will be useful,
00014 // but WITHOUT ANY WARRANTY; without even the implied warranty of
00015 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00016 // GNU General Public License for more details.
00017 //
00018 // You should have received a copy of the GNU General Public License
00019 // along with this program; if not, write to the
00020 // Free Software Foundation, Inc.,
00021 // 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
00022 
00027 #include "ClientSocketHandle.ih"
00028 
00029 // Custom includes
00030 #include <algorithm>
00031 #include <boost/utility/value_init.hpp>
00032 #include <senf/Utils/Buffer.hh>
00033 
00034 #define prefix_
00035 //-/////////////////////////////////////////////////////////////////////////////////////////////////
00036 
00037 //-/////////////////////////////////////////////////////////////////////////////////////////////////
00038 // senf::detail::ReadRange<Handle,ForwardWritableRange,IsContiguous>
00039 
00040 template <class Handle, class ForwardWritableRange, bool IsContiguous>
00041 prefix_ typename boost::range_iterator<ForwardWritableRange>::type
00042 senf::detail::ReadRange<Handle,ForwardWritableRange,IsContiguous>::
00043 read(Handle & handle, ForwardWritableRange & range)
00044 {
00045     typename boost::range_size<ForwardWritableRange>::type nread (boost::size(range));
00046     SENF_SCOPED_BUFFER(char, buffer, nread);
00047     return std::copy(buffer, handle.read(buffer,buffer+nread), boost::begin(range));
00048 }
00049 
00050 template <class Handle, class ForwardWritableRange, bool IsContiguous>
00051 prefix_ typename boost::range_iterator<ForwardWritableRange>::type
00052 senf::detail::ReadRange<Handle,ForwardWritableRange,IsContiguous>::
00053 readfrom(Handle & handle, ForwardWritableRange & range, typename Handle::Address & addr)
00054 {
00055     typename boost::range_size<ForwardWritableRange>::type nread (boost::size(range));
00056     SENF_SCOPED_BUFFER(char, buffer, nread);
00057     return std::copy(buffer, handle.readfrom(buffer,buffer+nread,addr), boost::begin(range));
00058 }
00059 
00060 //-/////////////////////////////////////////////////////////////////////////////////////////////////
00061 // senf::detail::WriteRange<Handle,ForwardReadableRange,IsContiguous>
00062 
00063 template <class Handle, class ForwardReadableRange, bool IsContiguous>
00064 prefix_ typename boost::range_const_iterator<ForwardReadableRange>::type
00065 senf::detail::WriteRange<Handle,ForwardReadableRange,IsContiguous>::
00066 write(Handle & handle, ForwardReadableRange & range)
00067 {
00068     typename boost::range_size<ForwardReadableRange>::type nwrite (boost::size(range));
00069     typename boost::range_const_iterator<ForwardReadableRange>::type i (boost::begin(range));
00070     SENF_SCOPED_BUFFER(char, buffer, nwrite);
00071     std::copy(i, boost::end(range), buffer);
00072     std::advance(i, handle.write(std::make_pair(buffer, buffer+nwrite)) - buffer);
00073     return i;
00074 }
00075 
00076 template <class Handle, class ForwardReadableRange, bool IsContiguous>
00077 prefix_ typename boost::range_const_iterator<ForwardReadableRange>::type
00078 senf::detail::WriteRange<Handle,ForwardReadableRange,IsContiguous>::
00079 writeto(Handle & handle, ForwardReadableRange & range, typename Handle::Address const & addr)
00080 {
00081     typename boost::range_size<ForwardReadableRange>::type nwrite (boost::size(range));
00082     typename boost::range_const_iterator<ForwardReadableRange>::type i (boost::begin(range));
00083     SENF_SCOPED_BUFFER(char, buffer, nwrite);
00084     std::copy(i, boost::end(range), buffer);
00085     std::advance(i, handle.writeto(std::make_pair(buffer, buffer+nwrite), addr) - buffer);
00086     return i;
00087 }
00088 
00089 //-/////////////////////////////////////////////////////////////////////////////////////////////////
00090 // senf::ClientSocketHandle<Policy>
00091 
00092 //-/////////////////////////////////////////////////////////////////////////////////////////////////
00093 // reading and writing
00094 
00095 // senf::ClientSocketHandle<Policy>::read
00096 
00097 template <class SPolicy>
00098 prefix_ std::string senf::ClientSocketHandle<SPolicy>::read(unsigned limit)
00099 {
00100     std::string rv;
00101     this->read(rv, limit);
00102     return rv;
00103 }
00104 
00105 template <class SPolicy>
00106 template <class Sequence>
00107 prefix_ void senf::ClientSocketHandle<SPolicy>::read(Sequence & container, unsigned limit)
00108 {
00109     if (limit == 0)
00110         limit = available();
00111     container.resize(limit);
00112     container.erase(read( std::make_pair(container.begin(), container.end()) ),
00113                     container.end());
00114 }
00115 
00116 // senf::ClientSocketHandle<SPolicy>::readfrom
00117 
00118 template <class SPolicy>
00119 prefix_ std::pair<std::string, typename SPolicy::AddressingPolicy::Address>
00120 senf::ClientSocketHandle<SPolicy>::readfrom(unsigned limit)
00121 {
00122     std::string rv;
00123     boost::value_initialized<typename SPolicy::AddressingPolicy::Address> addr;
00124     this->readfrom(rv, addr.data(), limit);
00125     return std::make_pair(rv, addr.data());
00126 }
00127 
00128 template <class SPolicy>
00129 template <class Sequence>
00130 prefix_ void senf::ClientSocketHandle<SPolicy>::readfrom(Sequence & container, Address & from,
00131                                                         unsigned limit)
00132 {
00133     if (limit == 0)
00134         limit = available();
00135     container.resize(limit);
00136     container.erase(readfrom( std::make_pair(container.begin(), container.end()), from ),
00137                     container.end());
00138 }
00139 
00140 //-/////////////////////////////////////////////////////////////////////////////////////////////////
00141 // private members
00142 
00143 // senf::ClientSocketHandle<SPolicy>::available
00144 
00145 template <class SPolicy>
00146 prefix_ unsigned senf::ClientSocketHandle<SPolicy>::available()
00147 {
00148     unsigned nread = this->protocol().available();
00149     if (nread == 0 && this->blocking()) {
00150         // We have to block explicitly here so we can return the
00151         // number of bytes available explicitly. If no more date can
00152         // be expected to arive (i.e. the other end has closed the
00153         // connection), the socket will always be in the readable
00154         // state. This is the only case when available() will return
00155         // 0.
00156         this->waitReadable();
00157         nread = this->protocol().available();
00158     }
00159     return nread;
00160 }
00161 
00162 //-/////////////////////////////////////////////////////////////////////////////////////////////////
00163 #undef prefix_
00164 
00165 
00166 // Local Variables:
00167 // mode: c++
00168 // fill-column: 100
00169 // c-file-style: "senf"
00170 // indent-tabs-mode: nil
00171 // ispell-local-dictionary: "american"
00172 // compile-command: "scons -u test"
00173 // comment-column: 40
00174 // End:
SENF Extensible Network Framework

ClientSocketHandle.ct
