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 inline template implementation
27 #include "ClientSocketHandle.ih"
32 #define prefix_ inline
33 ///////////////////////////////cti.p///////////////////////////////////////
35 ///////////////////////////////////////////////////////////////////////////
36 // senf::detail::ReadRange<Policy,ForwardWritableRange,true>
38 template <class Handle, class ForwardWritableRange>
39 prefix_ typename boost::range_iterator<ForwardWritableRange>::type
40 senf::detail::ReadRange<Handle,ForwardWritableRange,true>::read(Handle & handle,
41 ForwardWritableRange & range)
43 typename boost::range_iterator<ForwardWritableRange>::type const i (boost::begin(range));
44 char * const ic (reinterpret_cast<char*>(storage_iterator(i)));
45 return i + (handle.read( ic,
46 reinterpret_cast<char*>(storage_iterator(boost::end(range))) )
50 template <class Handle, class ForwardWritableRange>
51 prefix_ typename boost::range_iterator<ForwardWritableRange>::type
52 senf::detail::ReadRange<Handle,ForwardWritableRange,true>::
53 readfrom(Handle & handle, ForwardWritableRange & range, typename Handle::Address & addr)
55 typename boost::range_iterator<ForwardWritableRange>::type const i (boost::begin(range));
56 char * const ic (reinterpret_cast<char*>(storage_iterator(i)));
57 return i + (handle.readfrom( ic,
58 reinterpret_cast<char*>(storage_iterator(boost::end(range))),
63 ///////////////////////////////////////////////////////////////////////////
64 // senf::detail::WriteRange<Handle, ForwardReadableRange, true>
66 template <class Handle, class ForwardReadableRange>
67 prefix_ typename boost::range_const_iterator<ForwardReadableRange>::type
68 senf::detail::WriteRange<Handle, ForwardReadableRange, true>::
69 write(Handle & handle, ForwardReadableRange & range)
71 typename boost::range_const_iterator<ForwardReadableRange>::type i
72 (boost::const_begin(range));
73 char const * const ic (reinterpret_cast<char const *>(storage_iterator(i)));
74 std::advance(i, handle.write(ic,
75 reinterpret_cast<char const *>(
76 storage_iterator(boost::const_end(range)))) - ic);
80 template <class Handle, class ForwardReadableRange>
81 prefix_ typename boost::range_const_iterator<ForwardReadableRange>::type
82 senf::detail::WriteRange<Handle, ForwardReadableRange, true>::
83 writeto(Handle & handle, ForwardReadableRange & range, typename Handle::Address const & addr)
85 typename boost::range_const_iterator<ForwardReadableRange>::type i
86 (boost::const_begin(range));
87 char const * const ic (reinterpret_cast<char const *>(storage_iterator(i)));
88 std::advance(i, handle.writeto(addr, ic,
89 reinterpret_cast<char const *>(
90 storage_iterator(boost::const_end(range)))) - ic);
94 ///////////////////////////////////////////////////////////////////////////
95 // senf::ClientSocketHandle<Policy>
97 ////////////////////////////////////////
100 template <class Policy>
101 prefix_ senf::ClientSocketHandle<Policy>::ClientSocketHandle()
105 template <class Policy>
106 template <class OtherPolicy>
107 prefix_ senf::ClientSocketHandle<Policy>::
108 ClientSocketHandle(ClientSocketHandle<OtherPolicy> other,
109 typename SocketHandle<Policy>::template IsCompatible<OtherPolicy>::type *)
110 : SocketHandle<Policy>(other,true)
113 template <class Policy>
114 template <class OtherPolicy>
115 prefix_ senf::ClientSocketHandle<Policy>::
116 ClientSocketHandle(ClientSocketHandle<OtherPolicy> other)
120 template <class Policy>
121 prefix_ senf::ClientSocketHandle<Policy>::ClientSocketHandle(FileHandle other, bool isChecked)
122 : SocketHandle<Policy>(other, isChecked)
125 template <class Policy>
127 senf::ClientSocketHandle<Policy>::ClientSocketHandle(std::auto_ptr<SocketProtocol> protocol,
129 : SocketHandle<Policy>(protocol,false)
135 template <class Policy>
136 template <class OtherPolicy>
137 prefix_ typename senf::SocketHandle<Policy>::template IsCompatible<OtherPolicy>::type const &
138 senf::ClientSocketHandle<Policy>::operator=(ClientSocketHandle<OtherPolicy> other)
144 template <class Policy>
145 template <class OtherPolicy>
146 prefix_ OtherPolicy const &
147 senf::ClientSocketHandle<Policy>::operator=(ClientSocketHandle<OtherPolicy> other)
151 ////////////////////////////////////////
152 // reading and writing
154 // senf::ClientSocketHandle<Policy>::read
157 template <class Policy>
158 template <class ForwardWritableRange>
159 prefix_ typename boost::range_iterator<ForwardWritableRange>::type
160 senf::ClientSocketHandle<Policy>::
161 read(ForwardWritableRange const & range,
162 typename boost::disable_if< boost::is_convertible<ForwardWritableRange,unsigned> >::type *)
164 return detail::ReadRange<
165 ClientSocketHandle<Policy>,
166 ForwardWritableRange const,
167 contiguous_storage_iterator<
168 typename boost::range_iterator<ForwardWritableRange>::type
169 >::value && sizeof(typename boost::range_value<ForwardWritableRange>::type)==sizeof(char)
170 >::read(*this, range);
173 template <class Policy>
174 template <class ForwardWritableRange>
175 prefix_ typename boost::range_iterator<ForwardWritableRange>::type
176 senf::ClientSocketHandle<Policy>::
177 read(ForwardWritableRange const & range)
182 template <class Policy>
183 template <class ForwardWritableRange>
184 prefix_ typename boost::range_iterator<ForwardWritableRange>::type
185 senf::ClientSocketHandle<Policy>::
186 read(ForwardWritableRange & range,
187 typename boost::disable_if< boost::is_convertible<ForwardWritableRange,unsigned> >::type *)
189 return detail::ReadRange<
190 ClientSocketHandle<Policy>,
191 ForwardWritableRange,
192 contiguous_storage_iterator<
193 typename boost::range_iterator<ForwardWritableRange>::type
194 >::value && sizeof(typename boost::range_value<ForwardWritableRange>::type)==sizeof(char)
195 >::read(*this, range);
198 template <class Policy>
199 template <class ForwardWritableRange>
200 prefix_ typename boost::range_iterator<ForwardWritableRange>::type
201 senf::ClientSocketHandle<Policy>::
202 read(ForwardWritableRange & range)
206 template <class Policy>
207 prefix_ char * senf::ClientSocketHandle<Policy>::read(char * start, char * end)
209 return start + Policy::ReadPolicy::read(*this, start, end-start);
212 // senf::ClientSocketHandle<Policy>::readfrom
214 template <class Policy>
215 template <class ForwardWritableRange>
216 prefix_ typename boost::range_iterator<ForwardWritableRange const>::type
217 senf::ClientSocketHandle<Policy>::readfrom(ForwardWritableRange const & range, Address & from)
219 return detail::ReadRange<
220 ClientSocketHandle<Policy>,
221 ForwardWritableRange const,
222 contiguous_storage_iterator<
223 typename boost::range_iterator<ForwardWritableRange>::type
224 >::value && sizeof(typename boost::range_value<ForwardWritableRange>::type)==sizeof(char)
225 >::readfrom(*this, range, from);
228 template <class Policy>
229 template <class ForwardWritableRange>
230 prefix_ typename boost::range_iterator<ForwardWritableRange>::type
231 senf::ClientSocketHandle<Policy>::readfrom(ForwardWritableRange & range, Address & from)
233 return detail::ReadRange<
234 ClientSocketHandle<Policy>,
235 ForwardWritableRange,
236 contiguous_storage_iterator<
237 typename boost::range_iterator<ForwardWritableRange>::type
238 >::value && sizeof(typename boost::range_value<ForwardWritableRange>::type)==sizeof(char)
239 >::readfrom(*this, range, from);
242 template <class Policy>
243 prefix_ char * senf::ClientSocketHandle<Policy>::readfrom(char * start, char * end,
246 return start + Policy::ReadPolicy::readfrom(*this, start, end-start, from);
249 // senf::ClientSocketHandle<Policy>::write
251 template <class Policy>
252 template <class ForwardReadableRange>
253 prefix_ typename boost::range_const_iterator<ForwardReadableRange const>::type
254 senf::ClientSocketHandle<Policy>::write(ForwardReadableRange const & range)
256 return detail::WriteRange<
257 ClientSocketHandle<Policy>,
258 ForwardReadableRange const,
259 contiguous_storage_iterator<
260 typename boost::range_iterator<ForwardReadableRange>::type
261 >::value && sizeof(typename boost::range_value<ForwardReadableRange>::type)==sizeof(char)
262 >::write(*this, range);
265 template <class Policy>
266 prefix_ char const * senf::ClientSocketHandle<Policy>::write(char const * start, char const * end)
268 return start + Policy::WritePolicy::write(*this, start, end-start);
271 // senf::ClientSocketHandle<Policy>::writeto
273 template <class Policy>
274 template <class ForwardReadableRange>
275 prefix_ typename boost::range_const_iterator<ForwardReadableRange const>::type
276 senf::ClientSocketHandle<Policy>::writeto(AddressParam addr, ForwardReadableRange const & range)
278 return detail::WriteRange<
279 ClientSocketHandle<Policy>,
280 ForwardReadableRange const,
281 contiguous_storage_iterator<
282 typename boost::range_iterator<ForwardReadableRange>::type
283 >::value && sizeof(typename boost::range_value<ForwardReadableRange>::type)==sizeof(char)
284 >::writeto(*this, range, addr);
287 template <class Policy>
288 prefix_ char const * senf::ClientSocketHandle<Policy>::writeto(AddressParam addr,
292 return start + Policy::WritePolicy::writeto(*this, addr, start, end-start);
295 ////////////////////////////////////////
298 // senf::ClientSocketHandle<Policy>::peer
300 template <class Policy>
301 prefix_ typename Policy::AddressingPolicy::Address
302 senf::ClientSocketHandle<Policy>::peer()
304 typename Policy::AddressingPolicy::Address addr;
309 template <class Policy>
310 prefix_ void senf::ClientSocketHandle<Policy>::
311 peer(typename Policy::AddressingPolicy::Address & addr)
313 Policy::AddressingPolicy::peer(*this,addr);
316 // senf::ClientSocketHandle<Policy>::local
318 template <class Policy>
319 prefix_ typename Policy::AddressingPolicy::Address
320 senf::ClientSocketHandle<Policy>::local()
322 typename Policy::AddressingPolicy::Address addr;
327 template <class Policy>
328 prefix_ void senf::ClientSocketHandle<Policy>::
329 local(typename Policy::AddressingPolicy::Address & addr)
331 Policy::AddressingPolicy::local(*this,addr);
334 // senf::ClientSocketHandle<Policy>::connect
336 template <class Policy>
337 prefix_ void senf::ClientSocketHandle<Policy>::connect(AddressParam addr)
339 Policy::AddressingPolicy::connect(*this,addr);
342 // senf::ClientSocketHandle<Policy>::bind
344 template <class Policy>
345 prefix_ void senf::ClientSocketHandle<Policy>::
346 bind(typename boost::call_traits<typename Policy::AddressingPolicy::Address>::param_type addr)
348 Policy::AddressingPolicy::bind(*this,addr);
351 ////////////////////////////////////////
354 // senf::ClientSocketHandle<Policy>::rcvbuf
356 template <class Policy>
357 prefix_ unsigned senf::ClientSocketHandle<Policy>::rcvbuf()
359 return Policy::BufferingPolicy::rcvbuf(*this);
362 template <class Policy>
363 prefix_ void senf::ClientSocketHandle<Policy>::rcvbuf(unsigned size)
365 Policy::BufferingPolicy::rcvbuf(*this,size);
368 // senf::ClientSocketHandle<Policy>::sndbuf
370 template <class Policy>
371 prefix_ unsigned senf::ClientSocketHandle<Policy>::sndbuf()
373 return Policy::BufferingPolicy::sndbuf(*this);
376 template <class Policy>
377 prefix_ void senf::ClientSocketHandle<Policy>::sndbuf(unsigned size)
379 Policy::BufferingPolicy::sndbuf(*this,size);
382 ////////////////////////////////////////
385 template <class Policy>
386 prefix_ senf::ClientSocketHandle<Policy>
387 senf::ClientSocketHandle<Policy>::cast_static(FileHandle handle)
389 return ClientSocketHandle(handle, true);
392 template <class Policy>
393 prefix_ senf::ClientSocketHandle<Policy>
394 senf::ClientSocketHandle<Policy>::cast_dynamic(FileHandle handle)
396 SocketHandle<Policy> h (SocketHandle<Policy>::cast_dynamic(handle));
397 if (static_cast<SocketBody&>(FileHandle::body(h)).isServer())
398 throw std::bad_cast();
399 return cast_static(handle);
402 ////////////////////////////////////////
405 template <class Policy>
406 prefix_ void senf::ClientSocketHandle<Policy>::state(SocketStateMap & map, unsigned lod)
408 map["handle"] = prettyName(typeid(*this));
409 this->body().state(map,lod);
412 template <class Policy>
413 prefix_ std::string senf::ClientSocketHandle<Policy>::dumpState(unsigned lod)
417 return detail::dumpState(map);
420 ///////////////////////////////cti.e///////////////////////////////////////
427 // c-file-style: "senf"
428 // indent-tabs-mode: nil
429 // ispell-local-dictionary: "american"
430 // compile-command: "scons -u test"
431 // comment-column: 40