PPI/SocketWriter.hh

   1 // Copyright (C) 2007
   2 // Fraunhofer Institut fuer offene Kommunikationssysteme (FOKUS)
   3 // Kompetenzzentrum fuer Satelitenkommunikation (SatCom)
   4 //     Stefan Bund <g0dil@berlios.de>
   5 //
   6 // This program is free software; you can redistribute it and/or modify
   7 // it under the terms of the GNU General Public License as published by
   8 // the Free Software Foundation; either version 2 of the License, or
   9 // (at your option) any later version.
  10 //
  11 // This program is distributed in the hope that it will be useful,
  12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 // GNU General Public License for more details.
  15 //
  16 // You should have received a copy of the GNU General Public License
  17 // along with this program; if not, write to the
  18 // Free Software Foundation, Inc.,
  19 // 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  20
  21 /** \file
  22     \brief SocketWriter public header */
  23
  24 #ifndef HH_SocketWriter_
  25 #define HH_SocketWriter_ 1
  26
  27 // Custom includes
  28 #include "../Packets/Packets.hh"
  29 #include "../Socket/ClientSocketHandle.hh"
  30 #include "../Socket/SocketPolicy.hh"
  31 #include "../Socket/ReadWritePolicy.hh"
  32 #include "../Socket/FramingPolicy.hh"
  33 #include "../Socket/CommunicationPolicy.hh"
  34 #include "Module.hh"
  35 #include "Connectors.hh"
  36
  37 //#include "SocketWriter.mpp"
  38 ///////////////////////////////hh.p////////////////////////////////////////
  39
  40 namespace senf {
  41 namespace ppi {
  42
  43     /** \brief Write helper for module::ActiveSocketWriter / module::PassiveSocketWriter
  44
  45         This write helper will write the packets completely as datagrams to the given socket.
  46      */
  47     class PacketWriter
  48     {
  49     public:
  50         typedef senf::ClientSocketHandle<
  51             senf::MakeSocketPolicy< senf::WriteablePolicy,
  52                                     senf::DatagramFramingPolicy,
  53                                     senf::ConnectedCommunicationPolicy>::policy > Handle;
  54                                         ///< Handle type supported by this writer
  55
  56         void operator()(Handle handle, Packet packet);
  57                                         ///< Write \a packet to \a handle
  58                                         /**< Write the complete \a packet as a datagram to \a
  59                                              handle.
  60                                              \param[in] handle Handle to write data to
  61                                              \param[in] packet Packet to write */
  62     };
  63
  64 }}
  65
  66 namespace senf {
  67 namespace ppi {
  68 namespace module {
  69
  70     /** \brief Output module writing data to arbitrary FileHandle
  71
  72         This output module will write data to a FileHandle object using a given \a Writer. This
  73         output module is active. This requires the file handle to be able to signal its readiness to
  74         accept more data via the Scheduler.
  75
  76         The default \a Writer is senf::ppi::PacketWriter which will write out the complete packet to
  77         the file handle.
  78
  79         A \a Writer must fulfill the following interface:
  80         \code
  81           class SomeWriter
  82           {
  83           public:
  84               typedef unspecified Handle;                          // type of handle requested
  85               SomeWriter();                                        // default constructible
  86               void operator()(Handle handle, Packet packet);       // insertion function
  87           };
  88         \endcode
  89         Whenever a packet is received for sending, the \a Writer's \c operator() is called.
  90
  91         \ingroup io_modules
  92      */
  93     template <class Writer=PacketWriter>
  94     class ActiveSocketWriter : public Module
  95     {
  96         SENF_PPI_MODULE(ActiveSocketWriter);
  97
  98     public:
  99         typedef typename Writer::Handle Handle; ///< Handle type requested by writer
 100
 101         connector::ActiveInput input; ///< Input connector from which data is received
 102
 103         ActiveSocketWriter(Handle handle); ///< Create new writer for the given handle
 104                                         /**< Data will be written to \a handle using \a Writer.
 105                                              \param[in] handle Handle to write data to */
 106     private:
 107         void write();
 108
 109         Handle handle_;
 110         IOEvent event_;
 111         Writer writer_;
 112     };
 113
 114     /** \brief Output module writing data to arbitrary FileHandle
 115
 116         This output module will write data to a FileHandle object using a given \a Writer. This
 117         output module is passive. This implies, that the output handle may not block. This also
 118         implies, that data will probably get lost if written to fast for the underlying transport
 119         mechanism. Either this is desired (like for a UDP socket) or some additional bandwidth
 120         shaping needs to be used.
 121
 122         The default \a Writer is senf::ppi::PacketWriter which will write out the complete packet to
 123         the file handle.
 124
 125         The \a Writer must fulfill the following interface:
 126         \code
 127           class SomeWriter
 128           {
 129           public:
 130               typedef unspecified Handle;                          // type of handle requested
 131               SomeWriter();                                        // default constructible
 132               void operator()(Handle handle, Packet packet);       // insertion function
 133           };
 134         \endcode
 135         Whenever a packet is received for sending, the \a Writer's \c operator() is called.
 136
 137         \ingroup io_modules
 138      */
 139     template <class Writer=PacketWriter>
 140     class PassiveSocketWriter : public Module
 141     {
 142         SENF_PPI_MODULE(PassiveSocketWriter);
 143
 144     public:
 145         typedef typename Writer::Handle Handle; ///< Handle type requested by writer
 146
 147         connector::PassiveInput input; ///< Input connector from which data is received
 148
 149         PassiveSocketWriter(Handle handle); ///< Create new writer for the given handle
 150                                         /**< Data will be written to \a handle using \a Writer.
 151                                              \param[in] handle Handle to write data to */
 152
 153     private:
 154         void write();
 155
 156         Handle handle_;
 157         Writer writer_;
 158     };
 159
 160 }}}
 161
 162
 163 ///////////////////////////////hh.e////////////////////////////////////////
 164 #include "SocketWriter.cci"
 165 #include "SocketWriter.ct"
 166 //#include "SocketWriter.cti"
 167 #endif
 168
 169 \f
 170 // Local Variables:
 171 // mode: c++
 172 // fill-column: 100
 173 // c-file-style: "senf"
 174 // indent-tabs-mode: nil
 175 // ispell-local-dictionary: "american"
 176 // compile-command: "scons -u test"
 177 // comment-column: 40
 178 // End: