#include "IOEvent.hh"
//#include "SocketSink.mpp"
-///////////////////////////////hh.p////////////////////////////////////////
+//-/////////////////////////////////////////////////////////////////////////////////////////////////
namespace senf {
namespace ppi {
///< Handle type supported by this writer
typedef Packet PacketType;
- void operator()(Handle handle, Packet const & packet);
+ bool operator()(Handle & handle, Packet const & packet);
///< Write \a packet to \a handle
/**< Write the complete \a packet as a datagram to \a
handle.
typename Handle::Address target() const; ///< Get current target address
void target(typename Handle::Address const & target); ///< Set target address
- void operator()(Handle handle, Packet const & packet); ///< Write \a packet to \a handle
+ bool operator()(Handle & handle, Packet const & packet); ///< Write \a packet to \a handle
/**< Write the complete \a packet as a datagram to \a
handle.
\param[in] handle Handle to write data to
void destination(senf::INet4SocketAddress & dest);
senf::INet4SocketAddress destination();
- void operator()(Handle handle, Packet const & packet);
+ bool operator()(Handle & handle, Packet const & packet);
///< Write \a packet to \a handle
/**< Write the complete \a packet as a datagram to \a
handle.
void destination(senf::INet6SocketAddress & dest);
senf::INet6SocketAddress destination();
- void operator()(Handle handle, Packet const & packet);
+ bool operator()(Handle & handle, Packet const & packet);
///< Write \a packet to \a handle
/**< Write the complete \a packet as a datagram to \a
handle.
SomeWriter(); // EITHER default constructible OR
SomeWriter(SomeWriter const & other); // copy constructible
- void operator()(Handle handle, Packet packet); // insertion function
+ bool operator()(Handle handle, Packet packet); // insertion function
};
\endcode
Whenever a packet is received for sending, the \a Writer's \c operator() is called.
\pre Requires \a Writer to be copy constructible
\param[in] writer Writer helper writing packet date to
the socket */
- explicit ActiveSocketSink(Handle handle); ///< Create new writer for the given handle
+ explicit ActiveSocketSink(Handle const & handle);
+ ///< Create new writer for the given handle
/**< Data will be written to \a handle using \a Writer.
\pre Requires \a Writer to be default constructible
\param[in] handle Handle to write data to */
- ActiveSocketSink(Handle handle, Writer const & writer);
+ ActiveSocketSink(Handle const & handle, Writer const & writer);
///< Create new writer for the given handle
/**< Data will be written to \a handle using \a Writer.
\pre Requires \a Writer to be copy constructible
Writer & writer(); ///< Access the Writer
Handle handle(); ///< Access handle
- void handle(Handle handle); ///< Set handle
+ void handle(Handle const & handle);
+ ///< Set handle
/**< Assigning an empty or in-valid() handle will disable
the module until a new. valid handle is assigned. */
able to handle complete datagrams.
This output module will write data to a FileHandle object using a given \a Writer. This
- output module is passive. This implies, that the output handle may not block. This also
- implies, that data will probably get lost if written to fast for the underlying transport
- mechanism. Either this is desired (like for a UDP socket) or some additional bandwidth
- shaping needs to be used.
+ output module is passive. This implies, that <em>the output handle may not block</em>. This
+ also implies, that data will probably get lost if written to fast for the underlying
+ transport mechanism. Either this is desired (like for a UDP socket) or some additional
+ bandwidth shaping needs to be used.
The default \a Writer is senf::ppi::ConnectedDgramWriter which will write out the complete packet to
the file handle.
SomeWriter(); // EITHER default constructible
SomeWriter(SomeWriter const & other); // OR copy constructible
- void operator()(Handle handle, Packet packet); // insertion function
+ bool operator()(Handle handle, Packet packet); // insertion function
};
\endcode
Whenever a packet is received for sending, the \a Writer's \c operator() is called.
\pre Requires \a Writer to be copy constructible
\param[in] writer Writer helper writing packet date to
the socket */
- explicit PassiveSocketSink(Handle handle); ///< Create new writer for the given handle
+ explicit PassiveSocketSink(Handle const & handle);
+ ///< Create new writer for the given handle
/**< Data will be written to \a handle using \a Writer.
\pre Requires \a Writer to be default constructible
\param[in] handle Handle to write data to */
- PassiveSocketSink(Handle handle, Writer const & writer);
+ PassiveSocketSink(Handle const & handle, Writer const & writer);
///< Create new writer for the given handle
/**< Data will be written to \a handle using \a Writer.
\pre Requires \a Writer to be copy constructible
Writer & writer(); ///< Access the Writer
Handle & handle(); ///< Access handle
- void handle(Handle handle); ///< Set handle
+ void handle(Handle const & handle);
+ ///< Set handle
/**< Assigning an empty or in-valid() handle will disable
- the module until a new. valid handle is assigned. */
+ the module until a new valid handle is assigned. */
#ifndef DOXYGEN
void replaceHandle(Handle newHandle);
}}}
-///////////////////////////////hh.e////////////////////////////////////////
+//-/////////////////////////////////////////////////////////////////////////////////////////////////
#include "SocketSink.cci"
#include "SocketSink.ct"
#include "SocketSink.cti"
#endif
-
+\f
// Local Variables:
// mode: c++
// fill-column: 100
projects / senf.git / blobdiff