X-Git-Url: http://g0dil.de/git?a=blobdiff_plain;f=Socket%2FClientSocketHandle.cti;h=079229dbf4c1a86f570400d4dd716ed5bd987d9c;hb=5443435c4c2b6e4386c5334b5b8358273f2bae93;hp=c6a934868128db5b25c51c9cd78c2d89ad9727e8;hpb=ac6a813d9d99f7add4e13aff7a4bcd314d5604a6;p=senf.git

diff --git a/Socket/ClientSocketHandle.cti b/Socket/ClientSocketHandle.cti
index c6a9348..079229d 100644
--- a/Socket/ClientSocketHandle.cti
+++ b/Socket/ClientSocketHandle.cti
@@ -1,9 +1,9 @@
 // $Id$
 //
-// Copyright (C) 2006 
-// Fraunhofer Institut fuer offene Kommunikationssysteme (FOKUS)
-// Kompetenzzentrum fuer Satelitenkommunikation (SatCom)
-//     Stefan Bund <stefan.bund@fokus.fraunhofer.de>
+// Copyright (C) 2006
+// Fraunhofer Institute for Open Communication Systems (FOKUS)
+// Competence Center NETwork research (NET), St. Augustin, GERMANY
+//     Stefan Bund <g0dil@berlios.de>
 //
 // This program is free software; you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by
@@ -20,9 +20,11 @@
 // Free Software Foundation, Inc.,
 // 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 
-// Definition of inline template functions
+/** \file
+    \brief ClientSocketHandle inline template implementation
+ */
 
-//#include "ClientSocketHandle.ih"
+#include "ClientSocketHandle.ih"
 
 // Custom includes
 #include <typeinfo>
@@ -30,182 +32,356 @@
 #define prefix_ inline
 ///////////////////////////////cti.p///////////////////////////////////////
 
-template <class Policy>
+///////////////////////////////////////////////////////////////////////////
+// senf::detail::ReadRange<Policy,ForwardWritableRange,true>
+
+template <class Handle, class ForwardWritableRange>
+prefix_ typename boost::range_iterator<ForwardWritableRange>::type
+senf::detail::ReadRange<Handle,ForwardWritableRange,true>::read(Handle & handle,
+                                                                ForwardWritableRange & range)
+{
+    typename boost::range_iterator<ForwardWritableRange>::type const i (boost::begin(range));
+    char * const ic (reinterpret_cast<char*>(storage_iterator(i)));
+    return i + (handle.read( ic,
+                             reinterpret_cast<char*>(storage_iterator(boost::end(range))) )
+                - ic);
+}
+
+template <class Handle, class ForwardWritableRange>
+prefix_ typename boost::range_iterator<ForwardWritableRange>::type
+senf::detail::ReadRange<Handle,ForwardWritableRange,true>::
+readfrom(Handle & handle, ForwardWritableRange & range, typename Handle::Address & addr)
+{
+    typename boost::range_iterator<ForwardWritableRange>::type const i (boost::begin(range));
+    char * const ic (reinterpret_cast<char*>(storage_iterator(i)));
+    return i + (handle.readfrom( ic,
+                                 reinterpret_cast<char*>(storage_iterator(boost::end(range))),
+                                 addr )
+                - ic);
+}
+
+///////////////////////////////////////////////////////////////////////////
+// senf::detail::WriteRange<Handle, ForwardReadableRange, true>
+
+template <class Handle, class ForwardReadableRange>
+prefix_ typename boost::range_const_iterator<ForwardReadableRange>::type
+senf::detail::WriteRange<Handle, ForwardReadableRange, true>::
+write(Handle & handle, ForwardReadableRange & range)
+{
+    typename boost::range_const_iterator<ForwardReadableRange>::type i
+        (boost::const_begin(range));
+    char const * const ic (reinterpret_cast<char const *>(storage_iterator(i)));
+    std::advance(i, handle.write(ic,
+                                 reinterpret_cast<char const *>(
+                                     storage_iterator(boost::const_end(range)))) - ic);
+    return i;
+}
+
+template <class Handle, class ForwardReadableRange>
+prefix_ typename boost::range_const_iterator<ForwardReadableRange>::type
+senf::detail::WriteRange<Handle, ForwardReadableRange, true>::
+writeto(Handle & handle, ForwardReadableRange & range, typename Handle::Address const & addr)
+{
+    typename boost::range_const_iterator<ForwardReadableRange>::type i
+        (boost::const_begin(range));
+    char const * const ic (reinterpret_cast<char const *>(storage_iterator(i)));
+    std::advance(i, handle.writeto(addr, ic,
+                                   reinterpret_cast<char const *>(
+                                       storage_iterator(boost::const_end(range)))) - ic);
+    return i;
+}
+
+///////////////////////////////////////////////////////////////////////////
+// senf::ClientSocketHandle<Policy>
+
+////////////////////////////////////////
+// structors
+
+template <class SPolicy>
+prefix_ senf::ClientSocketHandle<SPolicy>::ClientSocketHandle()
+{}
+
+#ifndef DOXYGEN
+template <class SPolicy>
 template <class OtherPolicy>
-prefix_ senf::ClientSocketHandle<Policy>::
+prefix_ senf::ClientSocketHandle<SPolicy>::
 ClientSocketHandle(ClientSocketHandle<OtherPolicy> other,
-                   typename SocketHandle<Policy>::template IsCompatible<OtherPolicy>::type *)
-    : SocketHandle<Policy>(other,true)
+                   typename SocketHandle<SPolicy>::template IsCompatible<OtherPolicy>::type *)
+    : SocketHandle<SPolicy>(other,true)
 {}
+#else
+template <class SPolicy>
+template <class OtherPolicy>
+prefix_ senf::ClientSocketHandle<SPolicy>::
+ClientSocketHandle(ClientSocketHandle<OtherPolicy> other)
+{}
+#endif
 
-template <class Policy>
-prefix_ senf::ClientSocketHandle<Policy>::ClientSocketHandle(FileHandle other,
-                                                                    bool isChecked)
-    : SocketHandle<Policy>(other, isChecked)
+template <class SPolicy>
+prefix_ senf::ClientSocketHandle<SPolicy>::ClientSocketHandle(FileHandle other, bool isChecked)
+    : SocketHandle<SPolicy>(other, isChecked)
 {}
 
-template <class Policy>
-prefix_  senf::ClientSocketHandle<Policy>::
-ClientSocketHandle(std::auto_ptr<SocketProtocol> protocol, int fd)
-    : SocketHandle<Policy>(protocol,false)
-{
-    this->body().fd(fd);
-}
+template <class SPolicy>
+prefix_
+senf::ClientSocketHandle<SPolicy>::ClientSocketHandle(std::auto_ptr<SocketBody> body)
+    : SocketHandle<SPolicy>(body)
+{}
 
-template <class Policy>
+#ifndef DOXYGEN
+template <class SPolicy>
 template <class OtherPolicy>
-prefix_ typename senf::SocketHandle<Policy>::template IsCompatible<OtherPolicy>::type const &
-senf::ClientSocketHandle<Policy>::operator=(ClientSocketHandle<OtherPolicy> other)
+prefix_ typename senf::SocketHandle<SPolicy>::template IsCompatible<OtherPolicy>::type const &
+senf::ClientSocketHandle<SPolicy>::operator=(ClientSocketHandle<OtherPolicy> other)
 {
     assign(other);
     return *this;
 }
+#else
+template <class SPolicy>
+template <class OtherPolicy>
+prefix_ OtherPolicy const &
+senf::ClientSocketHandle<SPolicy>::operator=(ClientSocketHandle<OtherPolicy> other)
+{}
+#endif
 
-///////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////
 // reading and writing
 
-template <class Policy>
-prefix_ unsigned senf::ClientSocketHandle<Policy>::read(char * buffer,
-                                                                     unsigned size)
+// senf::ClientSocketHandle<SPolicy>::read
+
+#ifndef DOXYGEN
+template <class SPolicy>
+template <class ForwardWritableRange>
+prefix_ typename boost::range_iterator<ForwardWritableRange>::type
+senf::ClientSocketHandle<SPolicy>::
+read(ForwardWritableRange const & range,
+     typename boost::disable_if< boost::is_convertible<ForwardWritableRange,unsigned> >::type *)
+{
+    return detail::ReadRange<
+        ClientSocketHandle<SPolicy>,
+        ForwardWritableRange const,
+        contiguous_storage_iterator<
+            typename boost::range_iterator<ForwardWritableRange>::type
+        >::value && sizeof(typename boost::range_value<ForwardWritableRange>::type)==sizeof(char)
+        >::read(*this, range);
+}
+#else
+template <class SPolicy>
+template <class ForwardWritableRange>
+prefix_ typename boost::range_iterator<ForwardWritableRange>::type
+senf::ClientSocketHandle<SPolicy>::
+read(ForwardWritableRange const & range)
+{}
+#endif
+
+#ifndef DOXYGEN
+template <class SPolicy>
+template <class ForwardWritableRange>
+prefix_ typename boost::range_iterator<ForwardWritableRange>::type
+senf::ClientSocketHandle<SPolicy>::
+read(ForwardWritableRange & range,
+     typename boost::disable_if< boost::is_convertible<ForwardWritableRange,unsigned> >::type *)
 {
-    return Policy::ReadPolicy::read(*this, buffer, size);
+    return detail::ReadRange<
+        ClientSocketHandle<SPolicy>,
+        ForwardWritableRange,
+        contiguous_storage_iterator<
+            typename boost::range_iterator<ForwardWritableRange>::type
+        >::value && sizeof(typename boost::range_value<ForwardWritableRange>::type)==sizeof(char)
+        >::read(*this, range);
 }
+#else
+template <class SPolicy>
+template <class ForwardWritableRange>
+prefix_ typename boost::range_iterator<ForwardWritableRange>::type
+senf::ClientSocketHandle<SPolicy>::
+read(ForwardWritableRange & range)
+{}
+#endif
 
-template <class Policy>
-prefix_ unsigned senf::ClientSocketHandle<Policy>::
-readfrom(char * buffer, unsigned size, typename Policy::AddressingPolicy::Address & from)
+template <class SPolicy>
+prefix_ char * senf::ClientSocketHandle<SPolicy>::read(char * start, char * end)
 {
-    return Policy::ReadPolicy::readfrom(*this, buffer, size, from);
+    return start + SPolicy::ReadPolicy::read(*this, start, end-start);
 }
 
-template <class Policy>
-prefix_ unsigned senf::ClientSocketHandle<Policy>::write(char const * buffer,
-                                                                unsigned size)
+// senf::ClientSocketHandle<SPolicy>::readfrom
+
+template <class SPolicy>
+template <class ForwardWritableRange>
+prefix_ typename boost::range_iterator<ForwardWritableRange const>::type
+senf::ClientSocketHandle<SPolicy>::readfrom(ForwardWritableRange const & range, Address & from)
 {
-    return Policy::WritePolicy::write(*this, buffer, size);
+    return detail::ReadRange<
+        ClientSocketHandle<SPolicy>,
+        ForwardWritableRange const,
+        contiguous_storage_iterator<
+            typename boost::range_iterator<ForwardWritableRange>::type
+        >::value && sizeof(typename boost::range_value<ForwardWritableRange>::type)==sizeof(char)
+        >::readfrom(*this, range, from);
 }
 
-template <class Policy>
-prefix_ unsigned senf::ClientSocketHandle<Policy>::
-writeto(typename boost::call_traits<typename Policy::AddressingPolicy::Address>::param_type addr,
-        std::string const & data)
+template <class SPolicy>
+template <class ForwardWritableRange>
+prefix_ typename boost::range_iterator<ForwardWritableRange>::type
+senf::ClientSocketHandle<SPolicy>::readfrom(ForwardWritableRange & range, Address & from)
 {
-    return this->writeto(addr, data.data(), data.size());
+    return detail::ReadRange<
+        ClientSocketHandle<SPolicy>,
+        ForwardWritableRange,
+        contiguous_storage_iterator<
+            typename boost::range_iterator<ForwardWritableRange>::type
+        >::value && sizeof(typename boost::range_value<ForwardWritableRange>::type)==sizeof(char)
+        >::readfrom(*this, range, from);
 }
 
-template <class Policy>
-prefix_ unsigned senf::ClientSocketHandle<Policy>::
-writeto(typename boost::call_traits<typename Policy::AddressingPolicy::Address>::param_type addr,
-        char const * buffer, unsigned size)
+template <class SPolicy>
+prefix_ char * senf::ClientSocketHandle<SPolicy>::readfrom(char * start, char * end,
+                                                          Address & from)
 {
-    return Policy::WritePolicy::writeto(*this, addr, buffer, size);
+    return start + SPolicy::ReadPolicy::readfrom(*this, start, end-start, from);
 }
 
-///////////////////////////////////////////////////////////////////////////
-// addressing
+// senf::ClientSocketHandle<SPolicy>::write
 
-template <class Policy>
-prefix_ typename Policy::AddressingPolicy::Address
-senf::ClientSocketHandle<Policy>::peer()
+template <class SPolicy>
+template <class ForwardReadableRange>
+prefix_ typename boost::range_const_iterator<ForwardReadableRange const>::type
+senf::ClientSocketHandle<SPolicy>::write(ForwardReadableRange const & range)
 {
-    typename Policy::AddressingPolicy::Address addr;
-    this->peer(addr);
-    return addr;
+    return detail::WriteRange<
+        ClientSocketHandle<SPolicy>,
+        ForwardReadableRange const,
+        contiguous_storage_iterator<
+            typename boost::range_iterator<ForwardReadableRange>::type
+        >::value && sizeof(typename boost::range_value<ForwardReadableRange>::type)==sizeof(char)
+        >::write(*this, range);
 }
 
-template <class Policy>
-prefix_ void senf::ClientSocketHandle<Policy>::
-peer(typename Policy::AddressingPolicy::Address & addr)
+template <class SPolicy>
+prefix_ char const * senf::ClientSocketHandle<SPolicy>::write(char const * start, char const * end)
 {
-    Policy::AddressingPolicy::peer(*this,addr);
+    return start + SPolicy::WritePolicy::write(*this, start, end-start);
 }
 
-template <class Policy>
-prefix_ typename Policy::AddressingPolicy::Address
-senf::ClientSocketHandle<Policy>::local()
+// senf::ClientSocketHandle<SPolicy>::writeto
+
+template <class SPolicy>
+template <class ForwardReadableRange>
+prefix_ typename boost::range_const_iterator<ForwardReadableRange const>::type
+senf::ClientSocketHandle<SPolicy>::writeto(AddressParam addr, ForwardReadableRange const & range)
 {
-    typename Policy::AddressingPolicy::Address addr;
-    this->local(addr);
-    return addr;
+    return detail::WriteRange<
+        ClientSocketHandle<SPolicy>,
+        ForwardReadableRange const,
+        contiguous_storage_iterator<
+            typename boost::range_iterator<ForwardReadableRange>::type
+        >::value && sizeof(typename boost::range_value<ForwardReadableRange>::type)==sizeof(char)
+        >::writeto(*this, range, addr);
 }
 
-template <class Policy>
-prefix_ void senf::ClientSocketHandle<Policy>::
-local(typename Policy::AddressingPolicy::Address & addr)
+template <class SPolicy>
+prefix_ char const * senf::ClientSocketHandle<SPolicy>::writeto(AddressParam addr,
+                                                               char const * start,
+                                                               char const * end)
 {
-    Policy::AddressingPolicy::local(*this,addr);
+    return start + SPolicy::WritePolicy::writeto(*this, addr, start, end-start);
 }
 
-template <class Policy>
-prefix_ void senf::ClientSocketHandle<Policy>::connect(AddressParam addr)
+////////////////////////////////////////
+// addressing
+
+// senf::ClientSocketHandle<SPolicy>::peer
+
+template <class SPolicy>
+prefix_ typename SPolicy::AddressingPolicy::Address
+senf::ClientSocketHandle<SPolicy>::peer()
+    const
 {
-    Policy::AddressingPolicy::connect(*this,addr);
+    typename SPolicy::AddressingPolicy::Address addr;
+    this->peer(addr);
+    return addr;
 }
 
-template <class Policy>
-prefix_ void senf::ClientSocketHandle<Policy>::
-bind(typename boost::call_traits<typename Policy::AddressingPolicy::Address>::param_type addr)
+template <class SPolicy>
+prefix_ void senf::ClientSocketHandle<SPolicy>::
+peer(typename SPolicy::AddressingPolicy::Address & addr)
+    const
 {
-    Policy::AddressingPolicy::bind(*this,addr);
+    SPolicy::AddressingPolicy::peer(*this, addr);
 }
 
-///////////////////////////////////////////////////////////////////////////
-// Buffering
+// senf::ClientSocketHandle<SPolicy>::local
 
-template <class Policy>
-prefix_ unsigned senf::ClientSocketHandle<Policy>::rcvbuf()
+template <class SPolicy>
+prefix_ typename SPolicy::AddressingPolicy::Address
+senf::ClientSocketHandle<SPolicy>::local()
+    const
 {
-    return Policy::BufferingPolicy::rcvbuf(*this);
+    typename SPolicy::AddressingPolicy::Address addr;
+    this->local(addr);
+    return addr;
 }
 
-template <class Policy>
-prefix_ void senf::ClientSocketHandle<Policy>::rcvbuf(unsigned size)
+template <class SPolicy>
+prefix_ void senf::ClientSocketHandle<SPolicy>::
+local(typename SPolicy::AddressingPolicy::Address & addr)
+    const
 {
-    Policy::BufferingPolicy::rcvbuf(*this,size);
+    SPolicy::AddressingPolicy::local(*this,addr);
 }
 
-template <class Policy>
-prefix_ unsigned senf::ClientSocketHandle<Policy>::sndbuf()
+// senf::ClientSocketHandle<SPolicy>::connect
+
+template <class SPolicy>
+prefix_ void senf::ClientSocketHandle<SPolicy>::connect(AddressParam addr)
+    const
 {
-    return Policy::BufferingPolicy::sndbuf(*this);
+    SPolicy::AddressingPolicy::connect(*this, addr);
 }
 
-template <class Policy>
-prefix_ void senf::ClientSocketHandle<Policy>::sndbuf(unsigned size)
+// senf::ClientSocketHandle<SPolicy>::bind
+
+template <class SPolicy>
+prefix_ void senf::ClientSocketHandle<SPolicy>::bind(AddressParam addr)
+    const
 {
-    Policy::BufferingPolicy::sndbuf(*this,size);
+    SPolicy::AddressingPolicy::bind(*this, addr);
 }
 
-///////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////
+// Casting
 
-template <class Policy>
-prefix_ senf::ClientSocketHandle<Policy>
-senf::ClientSocketHandle<Policy>::cast_static(FileHandle handle)
+template <class SPolicy>
+prefix_ senf::ClientSocketHandle<SPolicy>
+senf::ClientSocketHandle<SPolicy>::cast_static(FileHandle handle)
 {
     return ClientSocketHandle(handle, true);
 }
 
-template <class Policy>
-prefix_ senf::ClientSocketHandle<Policy>
-senf::ClientSocketHandle<Policy>::cast_dynamic(FileHandle handle)
+template <class SPolicy>
+prefix_ senf::ClientSocketHandle<SPolicy>
+senf::ClientSocketHandle<SPolicy>::cast_dynamic(FileHandle handle)
 {
-    SocketHandle<Policy> h (SocketHandle<Policy>::cast_dynamic(handle));
+    SocketHandle<SPolicy> h (SocketHandle<SPolicy>::cast_dynamic(handle));
     if (static_cast<SocketBody&>(FileHandle::body(h)).isServer())
         throw std::bad_cast();
     return cast_static(handle);
 }
 
-template <class Policy>
-prefix_ void senf::ClientSocketHandle<Policy>::state(SocketStateMap & map, unsigned lod)
+////////////////////////////////////////
+// State information
+
+template <class SPolicy>
+prefix_ void senf::ClientSocketHandle<SPolicy>::state(SocketStateMap & map, unsigned lod)
 {
     map["handle"] = prettyName(typeid(*this));
-    this->body().state(map,lod);
+    this->body().state(map, lod);
 }
 
-template <class Policy>
-prefix_ std::string senf::ClientSocketHandle<Policy>::dumpState(unsigned lod)
+template <class SPolicy>
+prefix_ std::string senf::ClientSocketHandle<SPolicy>::dumpState(unsigned lod)
 {
     SocketStateMap map;
     state(map,lod);
@@ -218,5 +394,10 @@ prefix_ std::string senf::ClientSocketHandle<Policy>::dumpState(unsigned lod)
 
 // Local Variables:
 // mode: c++
+// fill-column: 100
 // c-file-style: "senf"
+// indent-tabs-mode: nil
+// ispell-local-dictionary: "american"
+// compile-command: "scons -u test"
+// comment-column: 40
 // End: