Connector.h

Go to the documentation of this file.

#ifndef H_CONNECTOR
#define H_CONNECTOR

#ifndef NO_DEPENDENCY_INCLUDES

#include "ProtocolRole.h"

#endif

namespace Connector 
{ 
    
    //
    // Basic Policies
    //
    
    // Just store the payload as payload_ protected member. 
    template< typename P > class SimplePayload
    { 
    protected: 
        P payload_; 
    public:
        typedef P PayloadType;
        virtual ~SimplePayload< P >( ) 
        { }
    };
    
    
    // upstream side functions as output location for previous operator
    template< typename P, typename B > 
    class MakesPayloadAvailableForOutput: 
        public B, public OutputPort< P > 
    {       
    public:
        // implementation of OutputPort<P>
        virtual operator P &()
        { return payload_; }
    };
    
    
    template< typename P, typename B > 
    class MakesPayloadAvailableForInput: 
        public B, public InputPort< P > 
    {
    public:
        // implementation of InputPort<U>
        virtual operator const P &()
        { return payload_; }
    };


    //
    // Slightly more complex payload_ policies
    //

    template< class U, class B > 
    class AdaptsPayloadForOutput: 
        public B, public OutputPort< typename U::PayloadType > 
    {
        U payloadAsU_;
    public:
        
        AdaptsPayloadForOutput<U,B>() : payloadAsU_( payload_ )
        { }
                
        // implementation of InputPort<U>
        virtual operator typename U::PayloadType &()
        { return payloadAsU_; }
    };
    
    
    template< class D, class B > 
    class AdaptsPayloadForInput: 
        public B, public InputPort< typename D::PayloadType > 
    {
        D payloadAsD_;
    public:
        
        AdaptsPayloadForInput<D,B>() : payloadAsD_( payload_ )
        { }
        
        // implementation of InputPort<U>
        virtual operator const typename D::PayloadType &()
        { return payloadAsD_; }
    };
    
    template< class D, class B > 
    class CopiesPayloadForInput: 
        public B, public InputPort< D > 
    {
        // secondary payload area which contains the translated/reordered data
        // example would be converting from C indexing to Fortran indexing
        // or changing from double to float..
        D payloadCopiedAsD_;
    public:
        
        CopiesPayloadForInput<D,B>() : payloadCopiedAsD_( payload_.size() )
        { }
        
        virtual ~CopiesPayloadForInput<D,B>() 
        { }
        
        // implementation of InputPort<U>
        
        // upon request for input buffer, operator receives a copy of the 
        // payload, with any attendant modifications or restructuring
        virtual operator const D &()
        { 
            // resize payloadCopiedAsD_ to be same size as payload_
            
            // copy content, changing double to float for instance
            // may need a functor template parameter if we want 
            // to do something like complex to real
            std::copy( payload_.begin(), payload_.end(), payloadCopiedAsD_.begin() );
            return payloadAsD_; 
        }
    };
    
    
    //
    // Connector Templates
    // 

    template<
        typename PayloadType
        >
    class SimpleConnector: 
        public MakesPayloadAvailableForInput < PayloadType, 
                    MakesPayloadAvailableForOutput < PayloadType,
                        SimplePayload< PayloadType > > >
    {
    };
    
    template< 
        typename UpstreamType,
        typename PayloadType,
        typename DownstreamType,
        template< class, class > class UpstreamPolicy 
            = AdaptsPayloadForOutput,
        template< class, class > class DownstreamPolicy 
            = AdaptsPayloadForInput,
        template< class > class PayloadPolicy 
            = SimplePayload
        > 
    class PoliciedConnector: 
        public UpstreamPolicy< UpstreamType,  
                 DownstreamPolicy< DownstreamType,
                    PayloadPolicy< PayloadType > > >
    {
    };
    
    
    template< class A, class B >
        class BlitzArrayFromMemoryBuffer : public A
    {
public:
        // we need to provide a clean constructor in order to be able to adapt
        BlitzArrayFromMemoryBuffer<A,B> ( B &it ):
        A( &it[0], blitz::shape( it.size() ), blitz::neverDeleteData )
    { }
        
        typedef A PayloadType;
    }; // class BlitzArrayFromMemoryBuffer
    
    
    
    template< class Payload >
        class ConstantInputPort: public InputPort< Payload >
    {
        Payload payload_;
public:
        ConstantInputPort<Payload>( const Payload &payload ): 
        payload_(payload) 
    { };
        virtual ~ConstantInputPort<Payload>() { };
        
        virtual operator const Payload & ( ) { return payload_; }; 
    }; // class ConstantInputPort
    
    
    
    
    template< class Key, class Payload >
        class ConstantLookupInputPort: public LookupInputPort< Key, Payload >
    {
        Payload payload_;
public:
        ConstantLookupInputPort<Key,Payload>( const Payload &payload ): 
        payload_(payload) 
    { }
        virtual ~ConstantLookupInputPort<Key,Payload>() { }
        
        // implementation of LookupInputPort<K,P>
        virtual const Payload &operator() ( const Key & ) { return payload_; } 
    }; // class TrivialLookupInputPort

    
    
    
    
}; // namespace

#endif // ifndef H_CONNECTOR

---