TestConnector.h

Go to the documentation of this file.

#ifndef H_TESTCONNECTOR
#define H_TESTCONNECTOR

#include <complex>
#include <iostream>

#ifndef NO_DEPENDENCY_INCLUDES

#include "Connector.h"

#endif 

namespace TestConnector
{
    
    // based on FixedMemoryBuffer from ConnectorTest.cc
    // a non-resizable vector; might be able to reuse std::vector to do this
    template< typename T, size_t Size >
    class Zeroes
{
    T data_[Size];
public:
    Zeroes<T,Size>() { memset( data_, 0, sizeof(data_) ); }
    inline operator T*( ) { return data_; }
    inline size_t size() const { return Size; }
}; // class Zeroes


// a policy preventing us from doing anything upstream
// also could be used as a downstream policy
template< class, class B >
class DoesNotProvidePort: public B
{ 
public:
    typedef typename B::PayloadType PayloadType;
}; // class DoesNotProvidePort


typedef double data_t;
typedef std::complex< data_t > complex_data_t;

// a test storage array of fixed size which we can put into a connector
typedef Zeroes< complex_data_t, 1024 > CZ1024;
typedef Zeroes< data_t, 1024 > RZ1024;

template< class P >
class ZeroFilledInputPort: 
public Connector::PoliciedConnector< 
int, // not used for much of anything 
CZ1024, // payload type
Connector::BlitzArrayFromMemoryBuffer< P, CZ1024 >,    // inputport payload type: can this be done as const P??
DoesNotProvidePort // upstream policy
>
{ };  // class ZeroFilledInputPort





// can you make a reference type into a payload.. 
class IostreamOutputPort: public Connector::OutputPort< std::ostream > 
{
    std::ostream &ios_;
public:
    IostreamOutputPort( std::ostream &ios ): ios_( ios ) { } 
    virtual ~IostreamOutputPort() { } 
    virtual operator std::ostream&( ) { return ios_; }
}; // class IostreamOutputPort


// given an initial case, return only that case, no matter what they key may be
template< class Key, class Payload >
class TrivialLookupInputPort: public Connector::LookupInputPort< Key, Payload >
{
    Payload payload_;
public:
    TrivialLookupInputPort<Key,Payload>( const Payload &payload ): 
    payload_(payload) 
    { }
    virtual ~TrivialLookupInputPort<Key,Payload>() { }
    
    // implementation of LookupInputPort<K,P>
    virtual const Payload &operator() ( const Key & ) { return payload_; } 
}; // class TrivialLookupInputPort





template< typename T >
class NoDownstreamCZ1024Connector: 
public Connector::PoliciedConnector< 
Connector::BlitzArrayFromMemoryBuffer< T, CZ1024 >, 
CZ1024,  
int,
Connector::AdaptsPayloadForOutput,
DoesNotProvidePort
>
{ }; // class NoDownstreamCZ1024Connector

template< typename T >
class NoDownstreamStructConnector: 
public Connector::MakesPayloadAvailableForOutput< T, 
Connector::SimplePayload< T > >
{ }; // class NoDownstreamStructConnector

}; // namespace TestConnector

#endif

---