Search:

SENF Extensible Network Framework

• Home
• Download
• Wiki
• BerliOS
• ChangeLog
• Browse SVN
• Bug Tracker

Connectors.hh

Go to the documentation of this file.

// $Id: Connectors.hh 1742 2010-11-04 14:51:56Z g0dil $
//
// Copyright (C) 2007
// Fraunhofer (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
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the
// Free Software Foundation, Inc.,
// 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

#ifndef HH_SENF_PPI_Connectors_
#define HH_SENF_PPI_Connectors_ 1

// Custom includes
#include <deque>
#include <boost/utility.hpp>
#include <boost/scoped_ptr.hpp>
#include <senf/Utils/safe_bool.hh>
#include <senf/Utils/Exception.hh>
#include <senf/Packets/Packets.hh>
#include "predecl.hh"
#include "detail/Callback.hh"
#include "Queueing.hh"
#include "ModuleManager.hh"

//#include "Connectors.mpp"
//-/////////////////////////////////////////////////////////////////////////////////////////////////

namespace senf {
namespace ppi {
namespace connector {

    struct IncompatibleConnectorsException : public senf::Exception
    { IncompatibleConnectorsException() : senf::Exception("Incompatible connectors") {} };

    class Connector
        : ModuleManager::Initializable, boost::noncopyable
    {
        SENF_LOG_CLASS_AREA();
        SENF_LOG_DEFAULT_LEVEL(senf::log::NOTICE);
    public:
        Connector & peer() const;       
        module::Module & module() const; 

        bool connected() const;         

        void disconnect();              

        enum TraceState { NO_TRACING, TRACE_IDS, TRACE_CONTENTS };

        static void tracing(TraceState state);
        static TraceState tracing();

    protected:
        Connector();
        virtual ~Connector();

        void connect(Connector & target);

        void trace(Packet const & p, char const * label);
        void throttleTrace(char const * label, char const * type);

        void unregisterConnector();

        virtual void v_disconnected();
        virtual void v_connected();

    private:
        virtual std::type_info const & packetTypeID();

        void setModule(module::Module & module);

        Connector * peer_;
        module::Module * module_;

        static TraceState traceState_;

        friend class module::Module;
    };

    class PassiveConnector
        : public virtual Connector
    {
    public:
        ~PassiveConnector();

        template <class Handler>
        void onRequest(Handler handler);

        bool throttled() const;         
        bool nativeThrottled() const;   

        void throttle();                
        void unthrottle();              

        ActiveConnector & peer() const;

    protected:
        PassiveConnector();

        void emit();

        virtual void v_disconnected();
        virtual void v_connected();

    private:
        virtual void v_init();

        // Called by the routing to change the throttling state from forwarding routes
        void notifyThrottle();          
        void notifyUnthrottle();        

        // Internal members to emit throttling notifications to the connected peer
        void emitThrottle();
        void emitUnthrottle();

        // Called after unthrottling the connector
        virtual void v_unthrottleEvent();

        // called by ForwardingRoute to register a new route
        void registerRoute(ForwardingRoute & route);
        void unregisterRoute(ForwardingRoute & route);

        ActiveConnector * peer_;

        typedef ppi::detail::Callback<>::type Callback;
        Callback callback_;

        bool remoteThrottled_;
        bool nativeThrottled_;

        typedef std::vector<ForwardingRoute*> Routes;
        Routes routes_;

        friend class senf::ppi::ForwardingRoute;
    };

    class ActiveConnector
        : public virtual Connector
    {
        typedef ppi::detail::Callback<>::type Callback;
    public:
        ~ActiveConnector();

        template <class Handler>
        void onThrottle(Handler handler); 

        void onThrottle();              

        template <class Handler>
        void onUnthrottle(Handler handler); 

        void onUnthrottle();            

        bool throttled() const;         

        PassiveConnector & peer() const;

    protected:
        ActiveConnector();

        virtual void v_disconnected();
        virtual void v_connected();

    private:
        virtual void v_init();

        // called by the peer() to forward throttling notifications
        void notifyThrottle();
        void notifyUnthrottle();

        // called by ForwardingRoute to register a new route
        void registerRoute(ForwardingRoute & route);
        void unregisterRoute(ForwardingRoute & route);

        PassiveConnector * peer_;

        Callback throttleCallback_;
        Callback unthrottleCallback_;

        typedef std::vector<ForwardingRoute*> NotifyRoutes;
        NotifyRoutes notifyRoutes_;

        bool throttled_;

        friend class senf::ppi::ForwardingRoute;
        friend class PassiveConnector;
    };

    class InputConnector
        : public virtual Connector
    {
        typedef std::deque<Packet> Queue;
    public:
        typedef Queue::const_iterator queue_iterator; 
        typedef Queue::size_type size_type; 


        Packet operator()();            

        Packet read();                  

        OutputConnector & peer() const;

        queue_iterator begin() const;   
        queue_iterator end() const;     
        Packet peek() const;            

        size_type queueSize() const;    
        bool empty() const;             

    protected:
        InputConnector();

        virtual void v_disconnected();
        virtual void v_connected();

    private:
        void enqueue(Packet const & p);

        virtual void v_requestEvent();
        virtual void v_enqueueEvent();
        virtual void v_dequeueEvent();

        OutputConnector * peer_;
        Queue queue_;

        friend class OutputConnector;
    };

    class OutputConnector
        : public virtual Connector
    {
    public:
        void operator()(Packet const & p);      

        void write(Packet const & p);           

        InputConnector & peer() const;

    protected:
        OutputConnector();

        virtual void v_disconnected();
        virtual void v_connected();

    private:
        InputConnector * peer_;
    };

    class GenericPassiveInput
        : public PassiveConnector, public InputConnector,
          public safe_bool<GenericPassiveInput>
    {
    public:
        GenericActiveOutput & peer() const;

        bool boolean_test() const;      

        template <class QDisc>
        void qdisc(QDisc const & disc); 

        void qdisc(QueueingDiscipline::None_t);

    protected:
        GenericPassiveInput();

        virtual void v_disconnected();
        virtual void v_connected();

    private:
        void v_enqueueEvent();
        void v_dequeueEvent();
        void v_unthrottleEvent();

        GenericActiveOutput * peer_;
        boost::scoped_ptr<QueueingDiscipline> qdisc_;
    };

    class GenericPassiveOutput
        : public PassiveConnector, public OutputConnector,
          public safe_bool<GenericPassiveOutput>
    {
    public:
        GenericActiveInput & peer() const;

        bool boolean_test() const;      

        void connect(GenericActiveInput & target); 

        friend class GenericActiveInput;

    protected:
        GenericPassiveOutput();

        virtual void v_disconnected();
        virtual void v_connected();

    private:
        GenericActiveInput * peer_;
    };

    class GenericActiveInput
        : public ActiveConnector, public InputConnector,
          public safe_bool<GenericActiveInput>
    {
    public:
        GenericPassiveOutput & peer() const;

        bool boolean_test() const;      

        void request();                 

    protected:
        GenericActiveInput();

        virtual void v_disconnected();
        virtual void v_connected();

    private:
        void v_requestEvent();

        GenericPassiveOutput * peer_;
    };

    class GenericActiveOutput
        : public ActiveConnector, public OutputConnector,
          public safe_bool<GenericActiveOutput>
    {
    public:
        GenericPassiveInput & peer() const;

        bool boolean_test() const;      

        void connect(GenericPassiveInput & target); 

    protected:
        GenericActiveOutput();

        virtual void v_disconnected();
        virtual void v_connected();

    private:
        GenericPassiveInput * peer_;
    };


#ifndef DOXYGEN

#   define TypedConnector_Input read
#   define TypedConnector_Output write
#   define TypedConnector(pType, dir)                                                             \
        template <class PacketType>                                                               \
        class pType ## dir                                                                        \
            : public Generic ## pType ## dir,                                                     \
              private detail::Typed ## dir ## Mixin<pType ## dir <PacketType>, PacketType>        \
        {                                                                                         \
            typedef detail::Typed ## dir ## Mixin<pType ## dir <PacketType>, PacketType> mixin;   \
        public:                                                                                   \
            using mixin::operator();                                                              \
            using mixin::TypedConnector_ ## dir ;                                                 \
        private:                                                                                  \
            virtual std::type_info const & packetTypeID()                                         \
                { return typeid(typename PacketType::type); }                                     \
            friend class detail::Typed ## dir ## Mixin<pType ## dir <PacketType>, PacketType>;    \
        };                                                                                        \
        template <>                                                                               \
        class pType ## dir <Packet> : public Generic ## pType ## dir                              \
        {}

    TypedConnector( Passive, Input  );
    TypedConnector( Passive, Output );
    TypedConnector( Active,  Input  );
    TypedConnector( Active,  Output );

#   undef TypedConnector
#   undef TypedConnector_Input
#   undef TypedConnector_Output

#else

    template <class PacketType=Packet>
    class ActiveInput : public GenericActiveInput
    {
    public:
        PacketType operator()();        

        PacketType read();              
    };

    template <class PacketType=Packet>
    class PassiveInput : public GenericPassiveInput
    {
    public:
        PacketType operator()();        

        PacketType read();              
    };

    template <class PacketType=Packet>
    class ActiveOutput : public GenericActiveOutput
    {
    public:
        void operator()(PacketType packet); 
        void write(PacketType packet);      
    };

    template <class PacketType=Packet>
    class PassiveOutput : public GenericPassiveOutput
    {
    public:
        void operator()(PacketType packet); 
        void write(PacketType packet);      
    };

#endif

}}}

//-/////////////////////////////////////////////////////////////////////////////////////////////////
#include "Connectors.cci"
#include "Connectors.ct"
#include "Connectors.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:

---

Contact: senf-dev@lists.berlios.de | © 2006-2010 Fraunhofer Institute for Open Communication Systems, Network Research