SocketSource.hh

Go to the documentation of this file.

//
// Copyright (c) 2020 Fraunhofer Institute for Applied Information Technology (FIT)
//                    Network Research Group (NET)
//                    Schloss Birlinghoven, 53754 Sankt Augustin, GERMANY
//                    Contact: support@wiback.org
//
// This file is part of the SENF code tree.
// It is licensed under the 3-clause BSD License (aka New BSD License).
// See LICENSE.txt in the top level directory for details or visit
// https://opensource.org/licenses/BSD-3-Clause
//


#ifndef HH_SENF_PPI_SocketSource_
#define HH_SENF_PPI_SocketSource_ 1

// Custom includes
#include <senf/Packets/Packets.hh>
#include <senf/Socket/ClientSocketHandle.hh>
#include <senf/Socket/SocketPolicy.hh>
#include <senf/Socket/ReadWritePolicy.hh>
#include <senf/Socket/FramingPolicy.hh>
#include "Module.hh"
#include "Connectors.hh"
#include "IOEvent.hh"

//#include "SocketSource.mpp"
//-/////////////////////////////////////////////////////////////////////////////////////////////////

namespace senf {
namespace ppi {


    struct ReadTimestamp
    {
        ClockService::clock_type value;
    };

    std::ostream & operator<<(std::ostream & os, ReadTimestamp const & annotation);

    template <class Packet=DataPacket, unsigned MaxSize=0u>
    class DgramReader
    {
    public:
        typedef Packet PacketType;
        typedef senf::ClientSocketHandle<
            senf::MakeSocketPolicy< senf::ReadablePolicy,
                                    senf::DatagramFramingPolicy >::policy > Handle;

        Packet operator()(Handle & handle);

    };

}}

namespace senf {
namespace ppi {
namespace module {

    template <class Reader=DgramReader<> >
    class ActiveSocketSource
        : public Module
    {
        SENF_PPI_MODULE(ActiveSocketSource);

    public:
        typedef typename Reader::Handle Handle; 

        connector::ActiveOutput<typename Reader::PacketType> output;

        ActiveSocketSource(unsigned max_burst=1);
        explicit ActiveSocketSource(Reader reader, unsigned max_burst=1);
        explicit ActiveSocketSource(Handle const & handle, unsigned max_burst=1);
        ActiveSocketSource(Handle const & handle, Reader reader, unsigned max_burst=1);

        Reader & reader();              
        Handle handle();                
        void handle(Handle const & handle);

        unsigned maxBurst() const;
        void maxBurst(unsigned max_burst);

        void flush();

        struct RxStats {
            RxStats () {
                clear();
            }
            void clear() {
                memset(this, 0, sizeof(*this));
            }
            void dump(std::ostream & os) const {
                os << "received "  << received << ", "
                   << "noop "       << noop << ".";
            }

            unsigned received;
            unsigned noop;
        };

        RxStats & rxStats() {
            return rxStats_;
        }
        
    private:
        Handle handle_;
        IOEvent event_;
        Reader reader_;
        unsigned maxBurst_;
        unsigned burst_;
        bool flush_pending_;
        RxStats rxStats_;
        void read();
    };

}}}

//-/////////////////////////////////////////////////////////////////////////////////////////////////
#include "SocketSource.cci"
#include "SocketSource.ct"
#include "SocketSource.cti"
#endif


// 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: