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
160 template <class SPolicy>
161 template <class ForwardWritableRange>
162 prefix_ typename boost::disable_if<boost::is_convertible<ForwardWritableRange,unsigned>,
163 typename boost::range_iterator<ForwardWritableRange>::type>::type
164 senf::ClientSocketHandle<SPolicy>::read(ForwardWritableRange const & range)
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::disable_if<boost::is_convertible<ForwardWritableRange,unsigned>,
187 typename boost::range_iterator<ForwardWritableRange>::type>::type
188 senf::ClientSocketHandle<SPolicy>::read(ForwardWritableRange & range)
190 return detail::ReadRange<
191 ClientSocketHandle<SPolicy>,
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 SPolicy>
200 template <class ForwardWritableRange>
201 prefix_ typename boost::range_iterator<ForwardWritableRange>::type
202 senf::ClientSocketHandle<SPolicy>::
203 read(ForwardWritableRange & range)
207 template <class SPolicy>
208 prefix_ char * senf::ClientSocketHandle<SPolicy>::read(char * start, char * end)
210 return start + SPolicy::ReadPolicy::read(*this, start, end-start);
213 // senf::ClientSocketHandle<SPolicy>::readfrom
215 template <class SPolicy>
216 template <class ForwardWritableRange>
217 prefix_ typename boost::range_iterator<ForwardWritableRange const>::type
218 senf::ClientSocketHandle<SPolicy>::readfrom(ForwardWritableRange const & range, Address & from)
220 return detail::ReadRange<
221 ClientSocketHandle<SPolicy>,
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 SPolicy>
230 template <class ForwardWritableRange>
231 prefix_ typename boost::range_iterator<ForwardWritableRange>::type
232 senf::ClientSocketHandle<SPolicy>::readfrom(ForwardWritableRange & range, Address & from)
234 return detail::ReadRange<
235 ClientSocketHandle<SPolicy>,
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 SPolicy>
244 prefix_ char * senf::ClientSocketHandle<SPolicy>::readfrom(char * start, char * end,
247 return start + SPolicy::ReadPolicy::readfrom(*this, start, end-start, from);
250 // senf::ClientSocketHandle<SPolicy>::write
252 template <class SPolicy>
253 template <class ForwardReadableRange>
254 prefix_ typename boost::range_const_iterator<ForwardReadableRange const>::type
255 senf::ClientSocketHandle<SPolicy>::write(ForwardReadableRange const & range)
257 return detail::WriteRange<
258 ClientSocketHandle<SPolicy>,
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 SPolicy>
267 prefix_ char const * senf::ClientSocketHandle<SPolicy>::write(char const * start, char const * end)
269 return start + SPolicy::WritePolicy::write(*this, start, end-start);
272 // senf::ClientSocketHandle<SPolicy>::writeto
274 template <class SPolicy>
275 template <class ForwardReadableRange>
276 prefix_ typename boost::range_const_iterator<ForwardReadableRange const>::type
277 senf::ClientSocketHandle<SPolicy>::writeto(AddressParam addr, ForwardReadableRange const & range)
279 return detail::WriteRange<
280 ClientSocketHandle<SPolicy>,
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 SPolicy>
289 prefix_ char const * senf::ClientSocketHandle<SPolicy>::writeto(AddressParam addr,
293 return start + SPolicy::WritePolicy::writeto(*this, addr, start, end-start);
296 //-/////////////////////////////////////////////////////////////////////////////////////////////////
299 // senf::ClientSocketHandle<SPolicy>::peer
301 template <class SPolicy>
302 prefix_ typename SPolicy::AddressingPolicy::Address
303 senf::ClientSocketHandle<SPolicy>::peer()
306 typename SPolicy::AddressingPolicy::Address addr;
311 template <class SPolicy>
312 prefix_ void senf::ClientSocketHandle<SPolicy>::
313 peer(typename SPolicy::AddressingPolicy::Address & addr)
316 SPolicy::AddressingPolicy::peer(*this, addr);
319 // senf::ClientSocketHandle<SPolicy>::local
321 template <class SPolicy>
322 prefix_ typename SPolicy::AddressingPolicy::Address
323 senf::ClientSocketHandle<SPolicy>::local()
326 typename SPolicy::AddressingPolicy::Address addr;
331 template <class SPolicy>
332 prefix_ void senf::ClientSocketHandle<SPolicy>::
333 local(typename SPolicy::AddressingPolicy::Address & addr)
336 SPolicy::AddressingPolicy::local(*this,addr);
339 // senf::ClientSocketHandle<SPolicy>::connect
341 template <class SPolicy>
342 prefix_ void senf::ClientSocketHandle<SPolicy>::connect(AddressParam addr)
345 SPolicy::AddressingPolicy::connect(*this, addr);
348 // senf::ClientSocketHandle<SPolicy>::bind
350 template <class SPolicy>
351 prefix_ void senf::ClientSocketHandle<SPolicy>::bind(AddressParam addr)
354 SPolicy::AddressingPolicy::bind(*this, addr);
357 //-/////////////////////////////////////////////////////////////////////////////////////////////////
360 template <class SPolicy>
361 prefix_ senf::ClientSocketHandle<SPolicy>
362 senf::ClientSocketHandle<SPolicy>::cast_static(FileHandle handle)
364 return ClientSocketHandle(handle, true);
367 template <class SPolicy>
368 prefix_ senf::ClientSocketHandle<SPolicy>
369 senf::ClientSocketHandle<SPolicy>::cast_dynamic(FileHandle handle)
371 SocketHandle<SPolicy> h (SocketHandle<SPolicy>::cast_dynamic(handle));
372 if (static_cast<SocketBody&>(FileHandle::body(h)).isServer())
373 throw std::bad_cast();
374 return cast_static(handle);
377 //-/////////////////////////////////////////////////////////////////////////////////////////////////
380 template <class SPolicy>
381 prefix_ void senf::ClientSocketHandle<SPolicy>::state(SocketStateMap & map, unsigned lod)
383 map["handle"] = prettyName(typeid(*this));
385 map["valid"] << "true";
386 this->body().state(map,lod);
388 map["valid"] << "false";
391 template <class SPolicy>
392 prefix_ std::string senf::ClientSocketHandle<SPolicy>::dumpState(unsigned lod)
396 return detail::dumpState(map);
399 //-/////////////////////////////////////////////////////////////////////////////////////////////////
406 // c-file-style: "senf"
407 // indent-tabs-mode: nil
408 // ispell-local-dictionary: "american"
409 // compile-command: "scons -u test"
410 // comment-column: 40