// $Id$
//
// Copyright (C) 2006
-// Fraunhofer Institute for Open Communication Systems (FOKUS)
-// Competence Center NETwork research (NET), St. Augustin, GERMANY
+// 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
/** \file
\brief SocketProtocol and ConcreteSocketProtocol public header
-
- \idea We should optimize the protocol handling. Allocating a protocol instance for every socket
- body seems quite wasteful. We could derive SocketPolicy from SocketBody (probably privately,
- since private inheritance models more of 'has a' than 'is a'). This would allow to reduce
- the number of heap-allocations per socket to one which is good.
*/
// The private inheritance idea should indeed work very well: We just need to change the
\see
\ref handle_group \n
\ref policy_group
-
- \todo Complete the protocol interface implementations. Better distribution of members to
- protocol facets and more precise distribution of functionality among the facets.
*/
/** \defgroup concrete_protocol_group Protocol Implementations (Concrete Protocol Classes)
///////////////////////////////////////////////////////////////////////////
// Virtual interface
- virtual std::auto_ptr<SocketProtocol> clone() const = 0;
- ///< Polymorphically return a copy of this protocol class
- /**< This member will create a new copy of the protocol
- class on the heap.
- \attention This member must be implemented in every \e
- leaf protocol class to return a new instance of the
- appropriate type. */
-
virtual unsigned available() const = 0;
- ///< Return number of bytes available for reading without
- ///< blocking
+ ///< Return (maximum) number of bytes available for reading
+ ///< without < blocking
/**< This member will check in a (very, sigh) protocol
dependent way, how many bytes may be read from a socket
in a single (non-blocking) read operation. If the
returns ethernet frames, returning 1500 from
available() is ok). However, this should only be done
as a last resort. Also beware, that this number should
- not be to large since the socket layer will always need
- to allocate that number of bytes for the data to be
- read. */
+ not be too large since the socket layer will always
+ need to allocate that number of bytes for the data to
+ be read. */
virtual bool eof() const = 0; ///< Check for end-of-file condition
/**< This is another check which (like available()) is
::dup2()). */
private:
- // backpointer to owning SocketBody instance
-
- SocketBody & body() const;
+ virtual std::auto_ptr<SocketBody> clone(bool isServer) const = 0;
+ virtual std::auto_ptr<SocketBody> clone(int fd, bool isServer) const = 0;
+ virtual SocketBody & body() const = 0;
- SocketBody * body_;
friend class SocketBody;
};
- template <class Policy> class ClientSocketHandle;
- template <class Policy> class ServerSocketHandle;
+ template <class SPolicy> class ClientSocketHandle;
+ template <class SPolicy> class ServerSocketHandle;
/** \brief Concrete Socket Protocol implementation base class
ConcreteSocketProtocol is the base class of a concrete socket protocol implementation. The
final protocol class must inherit from ConcreteSocketProtocol. The template argument \a
- SocketPolicy must be set to the complete socket policy of the protocol.
+ SocketPolicy must be set to the complete socket policy of the protocol. \a Self is the name
+ of the final protocol class which inherits this class.
A protocol implementation may define the protocol interface directly. It can also
(additionally) make use of multiple inheritance to combine a set of protocol facets into a
\doc init_client init_server
*/
- template <class SocketPolicy>
+ template <class SocketPolicy, class Self>
class ConcreteSocketProtocol
: public virtual SocketProtocol
{
///////////////////////////////////////////////////////////////////////////
Policy const & policy() const;
-
+
protected:
ClientSocketHandle<Policy> clientHandle() const;
///< Get client handle for associated socket
this protocol instance */
private:
- Policy policy_;
+ virtual std::auto_ptr<SocketBody> clone(bool isServer) const;
+ virtual std::auto_ptr<SocketBody> clone(int fd, bool isServer) const;
+ virtual SocketBody & body() const;
+ Policy policy_;
};
/// @}