4 // Fraunhofer Institut fuer offene Kommunikationssysteme (FOKUS)
5 // Kompetenzzentrum fuer Satelitenkommunikation (SatCom)
6 // Stefan Bund <stefan.bund@fokus.fraunhofer.de>
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.
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.
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.
24 \brief ClientSocketHandle non-inline template implementation
27 #include "ClientSocketHandle.ih"
31 #include "Utils/Buffer.hh"
34 ///////////////////////////////ct.p////////////////////////////////////////
36 ///////////////////////////////////////////////////////////////////////////
37 // senf::detail::ReadRange<Handle,ForwardWritableRange,IsContiguous>
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)
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));
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)
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));
59 ///////////////////////////////////////////////////////////////////////////
60 // senf::detail::WriteRange<Handle,ForwardReadableRange,IsContiguous>
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)
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));
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)
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);
84 ///////////////////////////////////////////////////////////////////////////
85 // senf::ClientSocketHandle<Policy>
87 ////////////////////////////////////////
88 // reading and writing
90 // senf::ClientSocketHandle<Policy>::read
92 template <class Policy>
93 prefix_ std::string senf::ClientSocketHandle<Policy>::read(unsigned limit)
100 template <class Policy>
101 template <class Sequence>
102 prefix_ void senf::ClientSocketHandle<Policy>::read(Sequence & container, unsigned limit)
104 unsigned nread (available());
105 if (limit>0 && nread>limit)
107 container.resize(nread);
108 container.erase(read( std::make_pair(container.begin(), container.end()) ),
112 // senf::ClientSocketHandle<Policy>::readfrom
114 template <class Policy>
115 prefix_ std::pair<std::string, typename Policy::AddressingPolicy::Address>
116 senf::ClientSocketHandle<Policy>::readfrom(unsigned limit)
119 typename Policy::AddressingPolicy::Address addr;
120 this->readfrom(rv,addr,limit);
121 return std::make_pair(rv,addr);
124 template <class Policy>
125 template <class Sequence>
126 prefix_ void senf::ClientSocketHandle<Policy>::readfrom(Sequence & container, Address & from,
129 unsigned nread (available());
130 if (limit>0 && nread>limit)
132 container.resize(nread);
133 container.erase(readfrom( std::make_pair(container.begin(), container.end()), from ),
137 ////////////////////////////////////////
140 // senf::ClientSocketHandle<Policy>::available
142 template <class Policy>
143 prefix_ unsigned senf::ClientSocketHandle<Policy>::available()
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
153 this->waitReadable();
154 nread = this->protocol().available();
159 ///////////////////////////////ct.e////////////////////////////////////////
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