4 // Fraunhofer Institute for Open Communication Systems (FOKUS)
6 // The contents of this file are subject to the Fraunhofer FOKUS Public License
7 // Version 1.0 (the "License"); you may not use this file except in compliance
8 // with the License. You may obtain a copy of the License at
9 // http://senf.berlios.de/license.html
11 // The Fraunhofer FOKUS Public License Version 1.0 is based on,
12 // but modifies the Mozilla Public License Version 1.1.
13 // See the full license text for the amendments.
15 // Software distributed under the License is distributed on an "AS IS" basis,
16 // WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
17 // for the specific language governing rights and limitations under the License.
19 // The Original Code is Fraunhofer FOKUS code.
21 // The Initial Developer of the Original Code is Fraunhofer-Gesellschaft e.V.
22 // (registered association), Hansastraße 27 c, 80686 Munich, Germany.
23 // All Rights Reserved.
26 // Stefan Bund <g0dil@berlios.de>
29 \brief ClientSocketHandle inline template implementation
32 #include "ClientSocketHandle.ih"
37 #define prefix_ inline
38 //-/////////////////////////////////////////////////////////////////////////////////////////////////
40 //-/////////////////////////////////////////////////////////////////////////////////////////////////
41 // senf::detail::ReadRange<Policy,ForwardWritableRange,true>
43 template <class Handle, class ForwardWritableRange>
44 prefix_ typename boost::range_iterator<ForwardWritableRange>::type
45 senf::detail::ReadRange<Handle,ForwardWritableRange,true>::read(Handle & handle,
46 ForwardWritableRange & range)
48 typename boost::range_iterator<ForwardWritableRange>::type const i (boost::begin(range));
49 char * const ic (reinterpret_cast<char*>(storage_iterator(i)));
50 return i + (handle.read( ic,
51 reinterpret_cast<char*>(storage_iterator(boost::end(range))) )
55 template <class Handle, class ForwardWritableRange>
56 prefix_ typename boost::range_iterator<ForwardWritableRange>::type
57 senf::detail::ReadRange<Handle,ForwardWritableRange,true>::
58 readfrom(Handle & handle, ForwardWritableRange & range, typename Handle::Address & addr)
60 typename boost::range_iterator<ForwardWritableRange>::type const i (boost::begin(range));
61 char * const ic (reinterpret_cast<char*>(storage_iterator(i)));
62 return i + (handle.readfrom( ic,
63 reinterpret_cast<char*>(storage_iterator(boost::end(range))),
68 //-/////////////////////////////////////////////////////////////////////////////////////////////////
69 // senf::detail::WriteRange<Handle, ForwardReadableRange, true>
71 template <class Handle, class ForwardReadableRange>
72 prefix_ typename boost::range_const_iterator<ForwardReadableRange>::type
73 senf::detail::WriteRange<Handle, ForwardReadableRange, true>::
74 write(Handle & handle, ForwardReadableRange & range)
76 typename boost::range_const_iterator<ForwardReadableRange>::type i
77 (boost::const_begin(range));
78 char const * const ic (reinterpret_cast<char const *>(storage_iterator(i)));
79 std::advance(i, handle.write(ic,
80 reinterpret_cast<char const *>(
81 storage_iterator(boost::const_end(range)))) - ic);
85 template <class Handle, class ForwardReadableRange>
86 prefix_ typename boost::range_const_iterator<ForwardReadableRange>::type
87 senf::detail::WriteRange<Handle, ForwardReadableRange, true>::
88 writeto(Handle & handle, ForwardReadableRange & range, typename Handle::Address const & addr)
90 typename boost::range_const_iterator<ForwardReadableRange>::type i
91 (boost::const_begin(range));
92 char const * const ic (reinterpret_cast<char const *>(storage_iterator(i)));
93 std::advance(i, handle.writeto(addr, ic,
94 reinterpret_cast<char const *>(
95 storage_iterator(boost::const_end(range)))) - ic);
99 //-/////////////////////////////////////////////////////////////////////////////////////////////////
100 // senf::ClientSocketHandle<Policy>
102 //-/////////////////////////////////////////////////////////////////////////////////////////////////
105 template <class SPolicy>
106 prefix_ senf::ClientSocketHandle<SPolicy>::ClientSocketHandle()
110 template <class SPolicy>
111 template <class OtherPolicy>
112 prefix_ senf::ClientSocketHandle<SPolicy>::
113 ClientSocketHandle(ClientSocketHandle<OtherPolicy> other,
114 typename SocketHandle<SPolicy>::template IsCompatible<OtherPolicy>::type *)
115 : SocketHandle<SPolicy>(other,true)
118 template <class SPolicy>
119 template <class OtherPolicy>
120 prefix_ senf::ClientSocketHandle<SPolicy>::
121 ClientSocketHandle(ClientSocketHandle<OtherPolicy> other)
125 template <class SPolicy>
126 prefix_ senf::ClientSocketHandle<SPolicy>::ClientSocketHandle(FileHandle other, bool isChecked)
127 : SocketHandle<SPolicy>(other, isChecked)
130 template <class SPolicy>
132 senf::ClientSocketHandle<SPolicy>::ClientSocketHandle(std::auto_ptr<SocketBody> body)
133 : SocketHandle<SPolicy>(body)
137 template <class SPolicy>
138 template <class OtherPolicy>
139 prefix_ typename senf::SocketHandle<SPolicy>::template IsCompatible<OtherPolicy>::type const &
140 senf::ClientSocketHandle<SPolicy>::operator=(ClientSocketHandle<OtherPolicy> other)
146 template <class SPolicy>
147 template <class OtherPolicy>
148 prefix_ OtherPolicy const &
149 senf::ClientSocketHandle<SPolicy>::operator=(ClientSocketHandle<OtherPolicy> other)
153 //-/////////////////////////////////////////////////////////////////////////////////////////////////
154 // reading and writing
156 // senf::ClientSocketHandle<SPolicy>::read
159 template <class SPolicy>
160 template <class ForwardWritableRange>
161 prefix_ typename boost::range_iterator<ForwardWritableRange>::type
162 senf::ClientSocketHandle<SPolicy>::
163 read(ForwardWritableRange const & range,
164 typename boost::disable_if< boost::is_convertible<ForwardWritableRange,unsigned> >::type *)
166 return detail::ReadRange<
167 ClientSocketHandle<SPolicy>,
168 ForwardWritableRange const,
169 contiguous_storage_iterator<
170 typename boost::range_iterator<ForwardWritableRange>::type
171 >::value && sizeof(typename boost::range_value<ForwardWritableRange>::type)==sizeof(char)
172 >::read(*this, range);
175 template <class SPolicy>
176 template <class ForwardWritableRange>
177 prefix_ typename boost::range_iterator<ForwardWritableRange>::type
178 senf::ClientSocketHandle<SPolicy>::
179 read(ForwardWritableRange const & range)
184 template <class SPolicy>
185 template <class ForwardWritableRange>
186 prefix_ typename boost::range_iterator<ForwardWritableRange>::type
187 senf::ClientSocketHandle<SPolicy>::
188 read(ForwardWritableRange & range,
189 typename boost::disable_if< boost::is_convertible<ForwardWritableRange,unsigned> >::type *)
191 return detail::ReadRange<
192 ClientSocketHandle<SPolicy>,
193 ForwardWritableRange,
194 contiguous_storage_iterator<
195 typename boost::range_iterator<ForwardWritableRange>::type
196 >::value && sizeof(typename boost::range_value<ForwardWritableRange>::type)==sizeof(char)
197 >::read(*this, range);
200 template <class SPolicy>
201 template <class ForwardWritableRange>
202 prefix_ typename boost::range_iterator<ForwardWritableRange>::type
203 senf::ClientSocketHandle<SPolicy>::
204 read(ForwardWritableRange & range)
208 template <class SPolicy>
209 prefix_ char * senf::ClientSocketHandle<SPolicy>::read(char * start, char * end)
211 return start + SPolicy::ReadPolicy::read(*this, start, end-start);
214 // senf::ClientSocketHandle<SPolicy>::readfrom
216 template <class SPolicy>
217 template <class ForwardWritableRange>
218 prefix_ typename boost::range_iterator<ForwardWritableRange const>::type
219 senf::ClientSocketHandle<SPolicy>::readfrom(ForwardWritableRange const & range, Address & from)
221 return detail::ReadRange<
222 ClientSocketHandle<SPolicy>,
223 ForwardWritableRange const,
224 contiguous_storage_iterator<
225 typename boost::range_iterator<ForwardWritableRange>::type
226 >::value && sizeof(typename boost::range_value<ForwardWritableRange>::type)==sizeof(char)
227 >::readfrom(*this, range, from);
230 template <class SPolicy>
231 template <class ForwardWritableRange>
232 prefix_ typename boost::range_iterator<ForwardWritableRange>::type
233 senf::ClientSocketHandle<SPolicy>::readfrom(ForwardWritableRange & range, Address & from)
235 return detail::ReadRange<
236 ClientSocketHandle<SPolicy>,
237 ForwardWritableRange,
238 contiguous_storage_iterator<
239 typename boost::range_iterator<ForwardWritableRange>::type
240 >::value && sizeof(typename boost::range_value<ForwardWritableRange>::type)==sizeof(char)
241 >::readfrom(*this, range, from);
244 template <class SPolicy>
245 prefix_ char * senf::ClientSocketHandle<SPolicy>::readfrom(char * start, char * end,
248 return start + SPolicy::ReadPolicy::readfrom(*this, start, end-start, from);
251 // senf::ClientSocketHandle<SPolicy>::write
253 template <class SPolicy>
254 template <class ForwardReadableRange>
255 prefix_ typename boost::range_const_iterator<ForwardReadableRange const>::type
256 senf::ClientSocketHandle<SPolicy>::write(ForwardReadableRange const & range)
258 return detail::WriteRange<
259 ClientSocketHandle<SPolicy>,
260 ForwardReadableRange const,
261 contiguous_storage_iterator<
262 typename boost::range_iterator<ForwardReadableRange>::type
263 >::value && sizeof(typename boost::range_value<ForwardReadableRange>::type)==sizeof(char)
264 >::write(*this, range);
267 template <class SPolicy>
268 prefix_ char const * senf::ClientSocketHandle<SPolicy>::write(char const * start, char const * end)
270 return start + SPolicy::WritePolicy::write(*this, start, end-start);
273 // senf::ClientSocketHandle<SPolicy>::writeto
275 template <class SPolicy>
276 template <class ForwardReadableRange>
277 prefix_ typename boost::range_const_iterator<ForwardReadableRange const>::type
278 senf::ClientSocketHandle<SPolicy>::writeto(AddressParam addr, ForwardReadableRange const & range)
280 return detail::WriteRange<
281 ClientSocketHandle<SPolicy>,
282 ForwardReadableRange const,
283 contiguous_storage_iterator<
284 typename boost::range_iterator<ForwardReadableRange>::type
285 >::value && sizeof(typename boost::range_value<ForwardReadableRange>::type)==sizeof(char)
286 >::writeto(*this, range, addr);
289 template <class SPolicy>
290 prefix_ char const * senf::ClientSocketHandle<SPolicy>::writeto(AddressParam addr,
294 return start + SPolicy::WritePolicy::writeto(*this, addr, start, end-start);
297 //-/////////////////////////////////////////////////////////////////////////////////////////////////
300 // senf::ClientSocketHandle<SPolicy>::peer
302 template <class SPolicy>
303 prefix_ typename SPolicy::AddressingPolicy::Address
304 senf::ClientSocketHandle<SPolicy>::peer()
307 typename SPolicy::AddressingPolicy::Address addr;
312 template <class SPolicy>
313 prefix_ void senf::ClientSocketHandle<SPolicy>::
314 peer(typename SPolicy::AddressingPolicy::Address & addr)
317 SPolicy::AddressingPolicy::peer(*this, addr);
320 // senf::ClientSocketHandle<SPolicy>::local
322 template <class SPolicy>
323 prefix_ typename SPolicy::AddressingPolicy::Address
324 senf::ClientSocketHandle<SPolicy>::local()
327 typename SPolicy::AddressingPolicy::Address addr;
332 template <class SPolicy>
333 prefix_ void senf::ClientSocketHandle<SPolicy>::
334 local(typename SPolicy::AddressingPolicy::Address & addr)
337 SPolicy::AddressingPolicy::local(*this,addr);
340 // senf::ClientSocketHandle<SPolicy>::connect
342 template <class SPolicy>
343 prefix_ void senf::ClientSocketHandle<SPolicy>::connect(AddressParam addr)
346 SPolicy::AddressingPolicy::connect(*this, addr);
349 // senf::ClientSocketHandle<SPolicy>::bind
351 template <class SPolicy>
352 prefix_ void senf::ClientSocketHandle<SPolicy>::bind(AddressParam addr)
355 SPolicy::AddressingPolicy::bind(*this, addr);
358 //-/////////////////////////////////////////////////////////////////////////////////////////////////
361 template <class SPolicy>
362 prefix_ senf::ClientSocketHandle<SPolicy>
363 senf::ClientSocketHandle<SPolicy>::cast_static(FileHandle handle)
365 return ClientSocketHandle(handle, true);
368 template <class SPolicy>
369 prefix_ senf::ClientSocketHandle<SPolicy>
370 senf::ClientSocketHandle<SPolicy>::cast_dynamic(FileHandle handle)
372 SocketHandle<SPolicy> h (SocketHandle<SPolicy>::cast_dynamic(handle));
373 if (static_cast<SocketBody&>(FileHandle::body(h)).isServer())
374 throw std::bad_cast();
375 return cast_static(handle);
378 //-/////////////////////////////////////////////////////////////////////////////////////////////////
381 template <class SPolicy>
382 prefix_ void senf::ClientSocketHandle<SPolicy>::state(SocketStateMap & map, unsigned lod)
384 map["handle"] = prettyName(typeid(*this));
386 map["valid"] << "true";
387 this->body().state(map,lod);
389 map["valid"] << "false";
392 template <class SPolicy>
393 prefix_ std::string senf::ClientSocketHandle<SPolicy>::dumpState(unsigned lod)
397 return detail::dumpState(map);
400 //-/////////////////////////////////////////////////////////////////////////////////////////////////
407 // c-file-style: "senf"
408 // indent-tabs-mode: nil
409 // ispell-local-dictionary: "american"
410 // compile-command: "scons -u test"
411 // comment-column: 40