4 // Fraunhofer Institute for Open Communication Systems (FOKUS)
5 // Competence Center NETwork research (NET), St. Augustin, GERMANY
6 // Stefan Bund <g0dil@berlios.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 SPolicy>
101 prefix_ senf::ClientSocketHandle<SPolicy>::ClientSocketHandle()
105 template <class SPolicy>
106 template <class OtherPolicy>
107 prefix_ senf::ClientSocketHandle<SPolicy>::
108 ClientSocketHandle(ClientSocketHandle<OtherPolicy> other,
109 typename SocketHandle<SPolicy>::template IsCompatible<OtherPolicy>::type *)
110 : SocketHandle<SPolicy>(other,true)
113 template <class SPolicy>
114 template <class OtherPolicy>
115 prefix_ senf::ClientSocketHandle<SPolicy>::
116 ClientSocketHandle(ClientSocketHandle<OtherPolicy> other)
120 template <class SPolicy>
121 prefix_ senf::ClientSocketHandle<SPolicy>::ClientSocketHandle(FileHandle other, bool isChecked)
122 : SocketHandle<SPolicy>(other, isChecked)
125 template <class SPolicy>
127 senf::ClientSocketHandle<SPolicy>::ClientSocketHandle(std::auto_ptr<SocketBody> body)
128 : SocketHandle<SPolicy>(body)
132 template <class SPolicy>
133 template <class OtherPolicy>
134 prefix_ typename senf::SocketHandle<SPolicy>::template IsCompatible<OtherPolicy>::type const &
135 senf::ClientSocketHandle<SPolicy>::operator=(ClientSocketHandle<OtherPolicy> other)
141 template <class SPolicy>
142 template <class OtherPolicy>
143 prefix_ OtherPolicy const &
144 senf::ClientSocketHandle<SPolicy>::operator=(ClientSocketHandle<OtherPolicy> other)
148 ////////////////////////////////////////
149 // reading and writing
151 // senf::ClientSocketHandle<SPolicy>::read
154 template <class SPolicy>
155 template <class ForwardWritableRange>
156 prefix_ typename boost::range_iterator<ForwardWritableRange>::type
157 senf::ClientSocketHandle<SPolicy>::
158 read(ForwardWritableRange const & range,
159 typename boost::disable_if< boost::is_convertible<ForwardWritableRange,unsigned> >::type *)
161 return detail::ReadRange<
162 ClientSocketHandle<SPolicy>,
163 ForwardWritableRange const,
164 contiguous_storage_iterator<
165 typename boost::range_iterator<ForwardWritableRange>::type
166 >::value && sizeof(typename boost::range_value<ForwardWritableRange>::type)==sizeof(char)
167 >::read(*this, range);
170 template <class SPolicy>
171 template <class ForwardWritableRange>
172 prefix_ typename boost::range_iterator<ForwardWritableRange>::type
173 senf::ClientSocketHandle<SPolicy>::
174 read(ForwardWritableRange const & range)
179 template <class SPolicy>
180 template <class ForwardWritableRange>
181 prefix_ typename boost::range_iterator<ForwardWritableRange>::type
182 senf::ClientSocketHandle<SPolicy>::
183 read(ForwardWritableRange & range,
184 typename boost::disable_if< boost::is_convertible<ForwardWritableRange,unsigned> >::type *)
186 return detail::ReadRange<
187 ClientSocketHandle<SPolicy>,
188 ForwardWritableRange,
189 contiguous_storage_iterator<
190 typename boost::range_iterator<ForwardWritableRange>::type
191 >::value && sizeof(typename boost::range_value<ForwardWritableRange>::type)==sizeof(char)
192 >::read(*this, range);
195 template <class SPolicy>
196 template <class ForwardWritableRange>
197 prefix_ typename boost::range_iterator<ForwardWritableRange>::type
198 senf::ClientSocketHandle<SPolicy>::
199 read(ForwardWritableRange & range)
203 template <class SPolicy>
204 prefix_ char * senf::ClientSocketHandle<SPolicy>::read(char * start, char * end)
206 return start + SPolicy::ReadPolicy::read(*this, start, end-start);
209 // senf::ClientSocketHandle<SPolicy>::readfrom
211 template <class SPolicy>
212 template <class ForwardWritableRange>
213 prefix_ typename boost::range_iterator<ForwardWritableRange const>::type
214 senf::ClientSocketHandle<SPolicy>::readfrom(ForwardWritableRange const & range, Address & from)
216 return detail::ReadRange<
217 ClientSocketHandle<SPolicy>,
218 ForwardWritableRange const,
219 contiguous_storage_iterator<
220 typename boost::range_iterator<ForwardWritableRange>::type
221 >::value && sizeof(typename boost::range_value<ForwardWritableRange>::type)==sizeof(char)
222 >::readfrom(*this, range, from);
225 template <class SPolicy>
226 template <class ForwardWritableRange>
227 prefix_ typename boost::range_iterator<ForwardWritableRange>::type
228 senf::ClientSocketHandle<SPolicy>::readfrom(ForwardWritableRange & range, Address & from)
230 return detail::ReadRange<
231 ClientSocketHandle<SPolicy>,
232 ForwardWritableRange,
233 contiguous_storage_iterator<
234 typename boost::range_iterator<ForwardWritableRange>::type
235 >::value && sizeof(typename boost::range_value<ForwardWritableRange>::type)==sizeof(char)
236 >::readfrom(*this, range, from);
239 template <class SPolicy>
240 prefix_ char * senf::ClientSocketHandle<SPolicy>::readfrom(char * start, char * end,
243 return start + SPolicy::ReadPolicy::readfrom(*this, start, end-start, from);
246 // senf::ClientSocketHandle<SPolicy>::write
248 template <class SPolicy>
249 template <class ForwardReadableRange>
250 prefix_ typename boost::range_const_iterator<ForwardReadableRange const>::type
251 senf::ClientSocketHandle<SPolicy>::write(ForwardReadableRange const & range)
253 return detail::WriteRange<
254 ClientSocketHandle<SPolicy>,
255 ForwardReadableRange const,
256 contiguous_storage_iterator<
257 typename boost::range_iterator<ForwardReadableRange>::type
258 >::value && sizeof(typename boost::range_value<ForwardReadableRange>::type)==sizeof(char)
259 >::write(*this, range);
262 template <class SPolicy>
263 prefix_ char const * senf::ClientSocketHandle<SPolicy>::write(char const * start, char const * end)
265 return start + SPolicy::WritePolicy::write(*this, start, end-start);
268 // senf::ClientSocketHandle<SPolicy>::writeto
270 template <class SPolicy>
271 template <class ForwardReadableRange>
272 prefix_ typename boost::range_const_iterator<ForwardReadableRange const>::type
273 senf::ClientSocketHandle<SPolicy>::writeto(AddressParam addr, ForwardReadableRange const & range)
275 return detail::WriteRange<
276 ClientSocketHandle<SPolicy>,
277 ForwardReadableRange const,
278 contiguous_storage_iterator<
279 typename boost::range_iterator<ForwardReadableRange>::type
280 >::value && sizeof(typename boost::range_value<ForwardReadableRange>::type)==sizeof(char)
281 >::writeto(*this, range, addr);
284 template <class SPolicy>
285 prefix_ char const * senf::ClientSocketHandle<SPolicy>::writeto(AddressParam addr,
289 return start + SPolicy::WritePolicy::writeto(*this, addr, start, end-start);
292 ////////////////////////////////////////
295 // senf::ClientSocketHandle<SPolicy>::peer
297 template <class SPolicy>
298 prefix_ typename SPolicy::AddressingPolicy::Address
299 senf::ClientSocketHandle<SPolicy>::peer()
301 typename SPolicy::AddressingPolicy::Address addr;
306 template <class SPolicy>
307 prefix_ void senf::ClientSocketHandle<SPolicy>::
308 peer(typename SPolicy::AddressingPolicy::Address & addr)
310 SPolicy::AddressingPolicy::peer(*this,addr);
313 // senf::ClientSocketHandle<SPolicy>::local
315 template <class SPolicy>
316 prefix_ typename SPolicy::AddressingPolicy::Address
317 senf::ClientSocketHandle<SPolicy>::local()
319 typename SPolicy::AddressingPolicy::Address addr;
324 template <class SPolicy>
325 prefix_ void senf::ClientSocketHandle<SPolicy>::
326 local(typename SPolicy::AddressingPolicy::Address & addr)
328 SPolicy::AddressingPolicy::local(*this,addr);
331 // senf::ClientSocketHandle<SPolicy>::connect
333 template <class SPolicy>
334 prefix_ void senf::ClientSocketHandle<SPolicy>::connect(AddressParam addr)
336 SPolicy::AddressingPolicy::connect(*this,addr);
339 // senf::ClientSocketHandle<SPolicy>::bind
341 template <class SPolicy>
342 prefix_ void senf::ClientSocketHandle<SPolicy>::
343 bind(typename boost::call_traits<typename SPolicy::AddressingPolicy::Address>::param_type addr)
345 SPolicy::AddressingPolicy::bind(*this,addr);
348 ////////////////////////////////////////
351 template <class SPolicy>
352 prefix_ senf::ClientSocketHandle<SPolicy>
353 senf::ClientSocketHandle<SPolicy>::cast_static(FileHandle handle)
355 return ClientSocketHandle(handle, true);
358 template <class SPolicy>
359 prefix_ senf::ClientSocketHandle<SPolicy>
360 senf::ClientSocketHandle<SPolicy>::cast_dynamic(FileHandle handle)
362 SocketHandle<SPolicy> h (SocketHandle<SPolicy>::cast_dynamic(handle));
363 if (static_cast<SocketBody&>(FileHandle::body(h)).isServer())
364 throw std::bad_cast();
365 return cast_static(handle);
368 ////////////////////////////////////////
371 template <class SPolicy>
372 prefix_ void senf::ClientSocketHandle<SPolicy>::state(SocketStateMap & map, unsigned lod)
374 map["handle"] = prettyName(typeid(*this));
375 this->body().state(map,lod);
378 template <class SPolicy>
379 prefix_ std::string senf::ClientSocketHandle<SPolicy>::dumpState(unsigned lod)
383 return detail::dumpState(map);
386 ///////////////////////////////cti.e///////////////////////////////////////
393 // c-file-style: "senf"
394 // indent-tabs-mode: nil
395 // ispell-local-dictionary: "american"
396 // compile-command: "scons -u test"
397 // comment-column: 40