ClientSocketHandle.cti

Go to the documentation of this file.
00001 // $Id: ClientSocketHandle.cti 1742 2010-11-04 14:51:56Z g0dil $
00002 //
00003 // Copyright (C) 2006
00004 // Fraunhofer (FOKUS)
00005 // Competence Center NETwork research (NET), St. Augustin, GERMANY
00006 //     Stefan Bund <g0dil@berlios.de>
00007 //
00008 // This program is free software; you can redistribute it and/or modify
00009 // it under the terms of the GNU General Public License as published by
00010 // the Free Software Foundation; either version 2 of the License, or
00011 // (at your option) any later version.
00012 //
00013 // This program is distributed in the hope that it will be useful,
00014 // but WITHOUT ANY WARRANTY; without even the implied warranty of
00015 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00016 // GNU General Public License for more details.
00017 //
00018 // You should have received a copy of the GNU General Public License
00019 // along with this program; if not, write to the
00020 // Free Software Foundation, Inc.,
00021 // 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
00022 
00027 #include "ClientSocketHandle.ih"
00028 
00029 // Custom includes
00030 #include <typeinfo>
00031 
00032 #define prefix_ inline
00033 //-/////////////////////////////////////////////////////////////////////////////////////////////////
00034 
00035 //-/////////////////////////////////////////////////////////////////////////////////////////////////
00036 // senf::detail::ReadRange<Policy,ForwardWritableRange,true>
00037 
00038 template <class Handle, class ForwardWritableRange>
00039 prefix_ typename boost::range_iterator<ForwardWritableRange>::type
00040 senf::detail::ReadRange<Handle,ForwardWritableRange,true>::read(Handle & handle,
00041                                                                 ForwardWritableRange & range)
00042 {
00043     typename boost::range_iterator<ForwardWritableRange>::type const i (boost::begin(range));
00044     char * const ic (reinterpret_cast<char*>(storage_iterator(i)));
00045     return i + (handle.read( ic,
00046                              reinterpret_cast<char*>(storage_iterator(boost::end(range))) )
00047                 - ic);
00048 }
00049 
00050 template <class Handle, class ForwardWritableRange>
00051 prefix_ typename boost::range_iterator<ForwardWritableRange>::type
00052 senf::detail::ReadRange<Handle,ForwardWritableRange,true>::
00053 readfrom(Handle & handle, ForwardWritableRange & range, typename Handle::Address & addr)
00054 {
00055     typename boost::range_iterator<ForwardWritableRange>::type const i (boost::begin(range));
00056     char * const ic (reinterpret_cast<char*>(storage_iterator(i)));
00057     return i + (handle.readfrom( ic,
00058                                  reinterpret_cast<char*>(storage_iterator(boost::end(range))),
00059                                  addr )
00060                 - ic);
00061 }
00062 
00063 //-/////////////////////////////////////////////////////////////////////////////////////////////////
00064 // senf::detail::WriteRange<Handle, ForwardReadableRange, true>
00065 
00066 template <class Handle, class ForwardReadableRange>
00067 prefix_ typename boost::range_const_iterator<ForwardReadableRange>::type
00068 senf::detail::WriteRange<Handle, ForwardReadableRange, true>::
00069 write(Handle & handle, ForwardReadableRange & range)
00070 {
00071     typename boost::range_const_iterator<ForwardReadableRange>::type i
00072         (boost::const_begin(range));
00073     char const * const ic (reinterpret_cast<char const *>(storage_iterator(i)));
00074     std::advance(i, handle.write(ic,
00075                                  reinterpret_cast<char const *>(
00076                                      storage_iterator(boost::const_end(range)))) - ic);
00077     return i;
00078 }
00079 
00080 template <class Handle, class ForwardReadableRange>
00081 prefix_ typename boost::range_const_iterator<ForwardReadableRange>::type
00082 senf::detail::WriteRange<Handle, ForwardReadableRange, true>::
00083 writeto(Handle & handle, ForwardReadableRange & range, typename Handle::Address const & addr)
00084 {
00085     typename boost::range_const_iterator<ForwardReadableRange>::type i
00086         (boost::const_begin(range));
00087     char const * const ic (reinterpret_cast<char const *>(storage_iterator(i)));
00088     std::advance(i, handle.writeto(addr, ic,
00089                                    reinterpret_cast<char const *>(
00090                                        storage_iterator(boost::const_end(range)))) - ic);
00091     return i;
00092 }
00093 
00094 //-/////////////////////////////////////////////////////////////////////////////////////////////////
00095 // senf::ClientSocketHandle<Policy>
00096 
00097 //-/////////////////////////////////////////////////////////////////////////////////////////////////
00098 // structors
00099 
00100 template <class SPolicy>
00101 prefix_ senf::ClientSocketHandle<SPolicy>::ClientSocketHandle()
00102 {}
00103 
00104 #ifndef DOXYGEN
00105 template <class SPolicy>
00106 template <class OtherPolicy>
00107 prefix_ senf::ClientSocketHandle<SPolicy>::
00108 ClientSocketHandle(ClientSocketHandle<OtherPolicy> other,
00109                    typename SocketHandle<SPolicy>::template IsCompatible<OtherPolicy>::type *)
00110     : SocketHandle<SPolicy>(other,true)
00111 {}
00112 #else
00113 template <class SPolicy>
00114 template <class OtherPolicy>
00115 prefix_ senf::ClientSocketHandle<SPolicy>::
00116 ClientSocketHandle(ClientSocketHandle<OtherPolicy> other)
00117 {}
00118 #endif
00119 
00120 template <class SPolicy>
00121 prefix_ senf::ClientSocketHandle<SPolicy>::ClientSocketHandle(FileHandle other, bool isChecked)
00122     : SocketHandle<SPolicy>(other, isChecked)
00123 {}
00124 
00125 template <class SPolicy>
00126 prefix_
00127 senf::ClientSocketHandle<SPolicy>::ClientSocketHandle(std::auto_ptr<SocketBody> body)
00128     : SocketHandle<SPolicy>(body)
00129 {}
00130 
00131 #ifndef DOXYGEN
00132 template <class SPolicy>
00133 template <class OtherPolicy>
00134 prefix_ typename senf::SocketHandle<SPolicy>::template IsCompatible<OtherPolicy>::type const &
00135 senf::ClientSocketHandle<SPolicy>::operator=(ClientSocketHandle<OtherPolicy> other)
00136 {
00137     assign(other);
00138     return *this;
00139 }
00140 #else
00141 template <class SPolicy>
00142 template <class OtherPolicy>
00143 prefix_ OtherPolicy const &
00144 senf::ClientSocketHandle<SPolicy>::operator=(ClientSocketHandle<OtherPolicy> other)
00145 {}
00146 #endif
00147 
00148 //-/////////////////////////////////////////////////////////////////////////////////////////////////
00149 // reading and writing
00150 
00151 // senf::ClientSocketHandle<SPolicy>::read
00152 
00153 #ifndef DOXYGEN
00154 template <class SPolicy>
00155 template <class ForwardWritableRange>
00156 prefix_ typename boost::range_iterator<ForwardWritableRange>::type
00157 senf::ClientSocketHandle<SPolicy>::
00158 read(ForwardWritableRange const & range,
00159      typename boost::disable_if< boost::is_convertible<ForwardWritableRange,unsigned> >::type *)
00160 {
00161     return detail::ReadRange<
00162         ClientSocketHandle<SPolicy>,
00163         ForwardWritableRange const,
00164         contiguous_storage_iterator<
00165             typename boost::range_iterator<ForwardWritableRange>::type
00166         >::value && sizeof(typename boost::range_value<ForwardWritableRange>::type)==sizeof(char)
00167         >::read(*this, range);
00168 }
00169 #else
00170 template <class SPolicy>
00171 template <class ForwardWritableRange>
00172 prefix_ typename boost::range_iterator<ForwardWritableRange>::type
00173 senf::ClientSocketHandle<SPolicy>::
00174 read(ForwardWritableRange const & range)
00175 {}
00176 #endif
00177 
00178 #ifndef DOXYGEN
00179 template <class SPolicy>
00180 template <class ForwardWritableRange>
00181 prefix_ typename boost::range_iterator<ForwardWritableRange>::type
00182 senf::ClientSocketHandle<SPolicy>::
00183 read(ForwardWritableRange & range,
00184      typename boost::disable_if< boost::is_convertible<ForwardWritableRange,unsigned> >::type *)
00185 {
00186     return detail::ReadRange<
00187         ClientSocketHandle<SPolicy>,
00188         ForwardWritableRange,
00189         contiguous_storage_iterator<
00190             typename boost::range_iterator<ForwardWritableRange>::type
00191         >::value && sizeof(typename boost::range_value<ForwardWritableRange>::type)==sizeof(char)
00192         >::read(*this, range);
00193 }
00194 #else
00195 template <class SPolicy>
00196 template <class ForwardWritableRange>
00197 prefix_ typename boost::range_iterator<ForwardWritableRange>::type
00198 senf::ClientSocketHandle<SPolicy>::
00199 read(ForwardWritableRange & range)
00200 {}
00201 #endif
00202 
00203 template <class SPolicy>
00204 prefix_ char * senf::ClientSocketHandle<SPolicy>::read(char * start, char * end)
00205 {
00206     return start + SPolicy::ReadPolicy::read(*this, start, end-start);
00207 }
00208 
00209 // senf::ClientSocketHandle<SPolicy>::readfrom
00210 
00211 template <class SPolicy>
00212 template <class ForwardWritableRange>
00213 prefix_ typename boost::range_iterator<ForwardWritableRange const>::type
00214 senf::ClientSocketHandle<SPolicy>::readfrom(ForwardWritableRange const & range, Address & from)
00215 {
00216     return detail::ReadRange<
00217         ClientSocketHandle<SPolicy>,
00218         ForwardWritableRange const,
00219         contiguous_storage_iterator<
00220             typename boost::range_iterator<ForwardWritableRange>::type
00221         >::value && sizeof(typename boost::range_value<ForwardWritableRange>::type)==sizeof(char)
00222         >::readfrom(*this, range, from);
00223 }
00224 
00225 template <class SPolicy>
00226 template <class ForwardWritableRange>
00227 prefix_ typename boost::range_iterator<ForwardWritableRange>::type
00228 senf::ClientSocketHandle<SPolicy>::readfrom(ForwardWritableRange & range, Address & from)
00229 {
00230     return detail::ReadRange<
00231         ClientSocketHandle<SPolicy>,
00232         ForwardWritableRange,
00233         contiguous_storage_iterator<
00234             typename boost::range_iterator<ForwardWritableRange>::type
00235         >::value && sizeof(typename boost::range_value<ForwardWritableRange>::type)==sizeof(char)
00236         >::readfrom(*this, range, from);
00237 }
00238 
00239 template <class SPolicy>
00240 prefix_ char * senf::ClientSocketHandle<SPolicy>::readfrom(char * start, char * end,
00241                                                           Address & from)
00242 {
00243     return start + SPolicy::ReadPolicy::readfrom(*this, start, end-start, from);
00244 }
00245 
00246 // senf::ClientSocketHandle<SPolicy>::write
00247 
00248 template <class SPolicy>
00249 template <class ForwardReadableRange>
00250 prefix_ typename boost::range_const_iterator<ForwardReadableRange const>::type
00251 senf::ClientSocketHandle<SPolicy>::write(ForwardReadableRange const & range)
00252 {
00253     return detail::WriteRange<
00254         ClientSocketHandle<SPolicy>,
00255         ForwardReadableRange const,
00256         contiguous_storage_iterator<
00257             typename boost::range_iterator<ForwardReadableRange>::type
00258         >::value && sizeof(typename boost::range_value<ForwardReadableRange>::type)==sizeof(char)
00259         >::write(*this, range);
00260 }
00261 
00262 template <class SPolicy>
00263 prefix_ char const * senf::ClientSocketHandle<SPolicy>::write(char const * start, char const * end)
00264 {
00265     return start + SPolicy::WritePolicy::write(*this, start, end-start);
00266 }
00267 
00268 // senf::ClientSocketHandle<SPolicy>::writeto
00269 
00270 template <class SPolicy>
00271 template <class ForwardReadableRange>
00272 prefix_ typename boost::range_const_iterator<ForwardReadableRange const>::type
00273 senf::ClientSocketHandle<SPolicy>::writeto(AddressParam addr, ForwardReadableRange const & range)
00274 {
00275     return detail::WriteRange<
00276         ClientSocketHandle<SPolicy>,
00277         ForwardReadableRange const,
00278         contiguous_storage_iterator<
00279             typename boost::range_iterator<ForwardReadableRange>::type
00280         >::value && sizeof(typename boost::range_value<ForwardReadableRange>::type)==sizeof(char)
00281         >::writeto(*this, range, addr);
00282 }
00283 
00284 template <class SPolicy>
00285 prefix_ char const * senf::ClientSocketHandle<SPolicy>::writeto(AddressParam addr,
00286                                                                char const * start,
00287                                                                char const * end)
00288 {
00289     return start + SPolicy::WritePolicy::writeto(*this, addr, start, end-start);
00290 }
00291 
00292 //-/////////////////////////////////////////////////////////////////////////////////////////////////
00293 // addressing
00294 
00295 // senf::ClientSocketHandle<SPolicy>::peer
00296 
00297 template <class SPolicy>
00298 prefix_ typename SPolicy::AddressingPolicy::Address
00299 senf::ClientSocketHandle<SPolicy>::peer()
00300     const
00301 {
00302     typename SPolicy::AddressingPolicy::Address addr;
00303     this->peer(addr);
00304     return addr;
00305 }
00306 
00307 template <class SPolicy>
00308 prefix_ void senf::ClientSocketHandle<SPolicy>::
00309 peer(typename SPolicy::AddressingPolicy::Address & addr)
00310     const
00311 {
00312     SPolicy::AddressingPolicy::peer(*this, addr);
00313 }
00314 
00315 // senf::ClientSocketHandle<SPolicy>::local
00316 
00317 template <class SPolicy>
00318 prefix_ typename SPolicy::AddressingPolicy::Address
00319 senf::ClientSocketHandle<SPolicy>::local()
00320     const
00321 {
00322     typename SPolicy::AddressingPolicy::Address addr;
00323     this->local(addr);
00324     return addr;
00325 }
00326 
00327 template <class SPolicy>
00328 prefix_ void senf::ClientSocketHandle<SPolicy>::
00329 local(typename SPolicy::AddressingPolicy::Address & addr)
00330     const
00331 {
00332     SPolicy::AddressingPolicy::local(*this,addr);
00333 }
00334 
00335 // senf::ClientSocketHandle<SPolicy>::connect
00336 
00337 template <class SPolicy>
00338 prefix_ void senf::ClientSocketHandle<SPolicy>::connect(AddressParam addr)
00339     const
00340 {
00341     SPolicy::AddressingPolicy::connect(*this, addr);
00342 }
00343 
00344 // senf::ClientSocketHandle<SPolicy>::bind
00345 
00346 template <class SPolicy>
00347 prefix_ void senf::ClientSocketHandle<SPolicy>::bind(AddressParam addr)
00348     const
00349 {
00350     SPolicy::AddressingPolicy::bind(*this, addr);
00351 }
00352 
00353 //-/////////////////////////////////////////////////////////////////////////////////////////////////
00354 // Casting
00355 
00356 template <class SPolicy>
00357 prefix_ senf::ClientSocketHandle<SPolicy>
00358 senf::ClientSocketHandle<SPolicy>::cast_static(FileHandle handle)
00359 {
00360     return ClientSocketHandle(handle, true);
00361 }
00362 
00363 template <class SPolicy>
00364 prefix_ senf::ClientSocketHandle<SPolicy>
00365 senf::ClientSocketHandle<SPolicy>::cast_dynamic(FileHandle handle)
00366 {
00367     SocketHandle<SPolicy> h (SocketHandle<SPolicy>::cast_dynamic(handle));
00368     if (static_cast<SocketBody&>(FileHandle::body(h)).isServer())
00369         throw std::bad_cast();
00370     return cast_static(handle);
00371 }
00372 
00373 //-/////////////////////////////////////////////////////////////////////////////////////////////////
00374 // State information
00375 
00376 template <class SPolicy>
00377 prefix_ void senf::ClientSocketHandle<SPolicy>::state(SocketStateMap & map, unsigned lod)
00378 {
00379     map["handle"] = prettyName(typeid(*this));
00380     if (this->valid()) {
00381         map["valid"] << "true";
00382         this->body().state(map,lod);
00383     } else
00384         map["valid"] << "false";
00385 }
00386 
00387 template <class SPolicy>
00388 prefix_ std::string senf::ClientSocketHandle<SPolicy>::dumpState(unsigned lod)
00389 {
00390     SocketStateMap map;
00391     state(map,lod);
00392     return detail::dumpState(map);
00393 }
00394 
00395 //-/////////////////////////////////////////////////////////////////////////////////////////////////
00396 #undef prefix_
00397 
00398 
00399 // Local Variables:
00400 // mode: c++
00401 // fill-column: 100
00402 // c-file-style: "senf"
00403 // indent-tabs-mode: nil
00404 // ispell-local-dictionary: "american"
00405 // compile-command: "scons -u test"
00406 // comment-column: 40
00407 // End:
SENF Extensible Network Framework

ClientSocketHandle.cti
