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 const i
72 (boost::const_begin(range));
73 char const * const ic (reinterpret_cast<char const *>(storage_iterator(i)));
74 return i + (handle.write(ic,
75 reinterpret_cast<char const *>(
76 storage_iterator(boost::const_end(range))))
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 const i
86 (boost::const_begin(range));
87 char const * const ic (reinterpret_cast<char const *>(storage_iterator(i)));
88 return i + (handle.writeto(addr,
90 reinterpret_cast<char const *>(
91 storage_iterator(boost::const_end(range))))
95 ///////////////////////////////////////////////////////////////////////////
96 // senf::ClientSocketHandle<Policy>
98 ////////////////////////////////////////
101 template <class Policy>
102 prefix_ senf::ClientSocketHandle<Policy>::ClientSocketHandle()
106 template <class Policy>
107 template <class OtherPolicy>
108 prefix_ senf::ClientSocketHandle<Policy>::
109 ClientSocketHandle(ClientSocketHandle<OtherPolicy> other,
110 typename SocketHandle<Policy>::template IsCompatible<OtherPolicy>::type *)
111 : SocketHandle<Policy>(other,true)
114 template <class Policy>
115 template <class OtherPolicy>
116 prefix_ senf::ClientSocketHandle<Policy>::
117 ClientSocketHandle(ClientSocketHandle<OtherPolicy> other)
121 template <class Policy>
122 prefix_ senf::ClientSocketHandle<Policy>::ClientSocketHandle(FileHandle other, bool isChecked)
123 : SocketHandle<Policy>(other, isChecked)
126 template <class Policy>
128 senf::ClientSocketHandle<Policy>::ClientSocketHandle(std::auto_ptr<SocketProtocol> protocol,
130 : SocketHandle<Policy>(protocol,false)
136 template <class Policy>
137 template <class OtherPolicy>
138 prefix_ typename senf::SocketHandle<Policy>::template IsCompatible<OtherPolicy>::type const &
139 senf::ClientSocketHandle<Policy>::operator=(ClientSocketHandle<OtherPolicy> other)
145 template <class Policy>
146 template <class OtherPolicy>
147 prefix_ OtherPolicy const &
148 senf::ClientSocketHandle<Policy>::operator=(ClientSocketHandle<OtherPolicy> other)
152 ////////////////////////////////////////
153 // reading and writing
155 // senf::ClientSocketHandle<Policy>::read
158 template <class Policy>
159 template <class ForwardWritableRange>
160 prefix_ typename boost::range_iterator<ForwardWritableRange>::type
161 senf::ClientSocketHandle<Policy>::
162 read(ForwardWritableRange const & range,
163 typename boost::disable_if< boost::is_convertible<ForwardWritableRange,unsigned> >::type *)
165 return detail::ReadRange<
166 ClientSocketHandle<Policy>,
167 ForwardWritableRange const,
168 contiguous_storage_iterator<
169 typename boost::range_iterator<ForwardWritableRange>::type
170 >::value && sizeof(typename boost::range_value<ForwardWritableRange>::type)==sizeof(char)
171 >::read(*this, range);
174 template <class Policy>
175 template <class ForwardWritableRange>
176 prefix_ typename boost::range_iterator<ForwardWritableRange>::type
177 senf::ClientSocketHandle<Policy>::
178 read(ForwardWritableRange const & range)
183 template <class Policy>
184 template <class ForwardWritableRange>
185 prefix_ typename boost::range_iterator<ForwardWritableRange>::type
186 senf::ClientSocketHandle<Policy>::
187 read(ForwardWritableRange & range,
188 typename boost::disable_if< boost::is_convertible<ForwardWritableRange,unsigned> >::type *)
190 return detail::ReadRange<
191 ClientSocketHandle<Policy>,
192 ForwardWritableRange,
193 contiguous_storage_iterator<
194 typename boost::range_iterator<ForwardWritableRange>::type
195 >::value && sizeof(typename boost::range_value<ForwardWritableRange>::type)==sizeof(char)
196 >::read(*this, range);
199 template <class Policy>
200 template <class ForwardWritableRange>
201 prefix_ typename boost::range_iterator<ForwardWritableRange>::type
202 senf::ClientSocketHandle<Policy>::
203 read(ForwardWritableRange & range)
207 template <class Policy>
208 prefix_ char * senf::ClientSocketHandle<Policy>::read(char * start, char * end)
210 return start + Policy::ReadPolicy::read(*this, start, end-start);
213 // senf::ClientSocketHandle<Policy>::readfrom
215 template <class Policy>
216 template <class ForwardWritableRange>
217 prefix_ typename boost::range_iterator<ForwardWritableRange const>::type
218 senf::ClientSocketHandle<Policy>::readfrom(ForwardWritableRange const & range, Address & from)
220 return detail::ReadRange<
221 ClientSocketHandle<Policy>,
222 ForwardWritableRange const,
223 contiguous_storage_iterator<
224 typename boost::range_iterator<ForwardWritableRange>::type
225 >::value && sizeof(typename boost::range_value<ForwardWritableRange>::type)==sizeof(char)
226 >::readfrom(*this, range, from);
229 template <class Policy>
230 template <class ForwardWritableRange>
231 prefix_ typename boost::range_iterator<ForwardWritableRange>::type
232 senf::ClientSocketHandle<Policy>::readfrom(ForwardWritableRange & range, Address & from)
234 return detail::ReadRange<
235 ClientSocketHandle<Policy>,
236 ForwardWritableRange,
237 contiguous_storage_iterator<
238 typename boost::range_iterator<ForwardWritableRange>::type
239 >::value && sizeof(typename boost::range_value<ForwardWritableRange>::type)==sizeof(char)
240 >::readfrom(*this, range, from);
243 template <class Policy>
244 prefix_ char * senf::ClientSocketHandle<Policy>::readfrom(char * start, char * end,
247 return start + Policy::ReadPolicy::readfrom(*this, start, end-start, from);
250 // senf::ClientSocketHandle<Policy>::write
252 template <class Policy>
253 template <class ForwardReadableRange>
254 prefix_ typename boost::range_const_iterator<ForwardReadableRange const>::type
255 senf::ClientSocketHandle<Policy>::write(ForwardReadableRange const & range)
257 return detail::WriteRange<
258 ClientSocketHandle<Policy>,
259 ForwardReadableRange const,
260 contiguous_storage_iterator<
261 typename boost::range_iterator<ForwardReadableRange>::type
262 >::value && sizeof(typename boost::range_value<ForwardReadableRange>::type)==sizeof(char)
263 >::write(*this, range);
266 template <class Policy>
267 prefix_ char const * senf::ClientSocketHandle<Policy>::write(char const * start, char const * end)
269 return start + Policy::WritePolicy::write(*this, start, end-start);
272 // senf::ClientSocketHandle<Policy>::writeto
274 template <class Policy>
275 template <class ForwardReadableRange>
276 prefix_ typename boost::range_const_iterator<ForwardReadableRange const>::type
277 senf::ClientSocketHandle<Policy>::writeto(AddressParam addr, ForwardReadableRange const & range)
279 return detail::WriteRange<
280 ClientSocketHandle<Policy>,
281 ForwardReadableRange const,
282 contiguous_storage_iterator<
283 typename boost::range_iterator<ForwardReadableRange>::type
284 >::value && sizeof(typename boost::range_value<ForwardReadableRange>::type)==sizeof(char)
285 >::writeto(*this, range, addr);
288 template <class Policy>
289 prefix_ char const * senf::ClientSocketHandle<Policy>::writeto(AddressParam addr,
293 return start + Policy::WritePolicy::writeto(*this, addr, start, end-start);
296 ////////////////////////////////////////
299 // senf::ClientSocketHandle<Policy>::peer
301 template <class Policy>
302 prefix_ typename Policy::AddressingPolicy::Address
303 senf::ClientSocketHandle<Policy>::peer()
305 typename Policy::AddressingPolicy::Address addr;
310 template <class Policy>
311 prefix_ void senf::ClientSocketHandle<Policy>::
312 peer(typename Policy::AddressingPolicy::Address & addr)
314 Policy::AddressingPolicy::peer(*this,addr);
317 // senf::ClientSocketHandle<Policy>::local
319 template <class Policy>
320 prefix_ typename Policy::AddressingPolicy::Address
321 senf::ClientSocketHandle<Policy>::local()
323 typename Policy::AddressingPolicy::Address addr;
328 template <class Policy>
329 prefix_ void senf::ClientSocketHandle<Policy>::
330 local(typename Policy::AddressingPolicy::Address & addr)
332 Policy::AddressingPolicy::local(*this,addr);
335 // senf::ClientSocketHandle<Policy>::connect
337 template <class Policy>
338 prefix_ void senf::ClientSocketHandle<Policy>::connect(AddressParam addr)
340 Policy::AddressingPolicy::connect(*this,addr);
343 // senf::ClientSocketHandle<Policy>::bind
345 template <class Policy>
346 prefix_ void senf::ClientSocketHandle<Policy>::
347 bind(typename boost::call_traits<typename Policy::AddressingPolicy::Address>::param_type addr)
349 Policy::AddressingPolicy::bind(*this,addr);
352 ////////////////////////////////////////
355 // senf::ClientSocketHandle<Policy>::rcvbuf
357 template <class Policy>
358 prefix_ unsigned senf::ClientSocketHandle<Policy>::rcvbuf()
360 return Policy::BufferingPolicy::rcvbuf(*this);
363 template <class Policy>
364 prefix_ void senf::ClientSocketHandle<Policy>::rcvbuf(unsigned size)
366 Policy::BufferingPolicy::rcvbuf(*this,size);
369 // senf::ClientSocketHandle<Policy>::sndbuf
371 template <class Policy>
372 prefix_ unsigned senf::ClientSocketHandle<Policy>::sndbuf()
374 return Policy::BufferingPolicy::sndbuf(*this);
377 template <class Policy>
378 prefix_ void senf::ClientSocketHandle<Policy>::sndbuf(unsigned size)
380 Policy::BufferingPolicy::sndbuf(*this,size);
383 ////////////////////////////////////////
386 template <class Policy>
387 prefix_ senf::ClientSocketHandle<Policy>
388 senf::ClientSocketHandle<Policy>::cast_static(FileHandle handle)
390 return ClientSocketHandle(handle, true);
393 template <class Policy>
394 prefix_ senf::ClientSocketHandle<Policy>
395 senf::ClientSocketHandle<Policy>::cast_dynamic(FileHandle handle)
397 SocketHandle<Policy> h (SocketHandle<Policy>::cast_dynamic(handle));
398 if (static_cast<SocketBody&>(FileHandle::body(h)).isServer())
399 throw std::bad_cast();
400 return cast_static(handle);
403 ////////////////////////////////////////
406 template <class Policy>
407 prefix_ void senf::ClientSocketHandle<Policy>::state(SocketStateMap & map, unsigned lod)
409 map["handle"] = prettyName(typeid(*this));
410 this->body().state(map,lod);
413 template <class Policy>
414 prefix_ std::string senf::ClientSocketHandle<Policy>::dumpState(unsigned lod)
418 return detail::dumpState(map);
421 ///////////////////////////////cti.e///////////////////////////////////////
428 // c-file-style: "senf"
429 // indent-tabs-mode: nil
430 // ispell-local-dictionary: "american"
431 // compile-command: "scons -u test"
432 // comment-column: 40