liboh/include/sirikata/oh/RouterElement.hpp

Go to the documentation of this file.

/*  Sirikata
 *  RouterElement.hpp
 *
 *  Copyright (c) 2009, Ewen Cheslack-Postava
 *  All rights reserved.
 *
 *  Redistribution and use in source and binary forms, with or without
 *  modification, are permitted provided that the following conditions are
 *  met:
 *  * Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *  * Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *  * Neither the name of Sirikata nor the names of its contributors may
 *    be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
 * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
 * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
 * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#ifndef _SIRIKATA_ROUTER_ELEMENT_
#define _SIRIKATA_ROUTER_ELEMENT_

#include <sirikata/core/util/Platform.hpp>
#include <sirikata/core/network/IOStrand.hpp>

namespace Sirikata {

// Forward declarations of classes below since they need to refer to
// each other
template<typename PacketType>
class DownstreamElementBase;
template<typename PacketType>
class UpstreamElementBase;


template<typename PacketType>
class DownstreamElementBase {
public:
    typedef UpstreamElementBase<PacketType> InputElement;

    virtual ~DownstreamElementBase() {}

    virtual bool connectInput(uint32 inport, InputElement* elmt, uint32 outport) {
        InputPort& i = input(inport);
        i.set(elmt, outport);
        return true;
    }

    virtual bool push(uint32 port, PacketType* pkt) = 0;

protected:
    class InputPort {
    public:
        InputPort()
         : element(NULL),
           port()
        {}

        bool set(InputElement* elmt, uint32 _port) {
            element = elmt;
            port = _port;
            return true;
        }

        PacketType* pull() {
            assert(element != NULL);
            return element->pull(port);
        }

        InputElement* element;
        uint32 port;
    };

    virtual InputPort& input(uint32 k) = 0;
}; // class DownstreamElementBase

template<typename PacketType, uint32 NumInputs>
class DownstreamElementFixed : public DownstreamElementBase<PacketType> {
public:
    typedef typename DownstreamElementBase<PacketType>::InputElement InputElement;

    DownstreamElementFixed() {
        memset(mInputPorts, 0, sizeof(InputPort)*NumInputs);
    };

protected:
    typedef typename DownstreamElementBase<PacketType>::InputPort InputPort;

    virtual InputPort& input(uint32 k) {
        assert(k < NumInputs);
        return mInputPorts[k];
    }

    InputPort mInputPorts[NumInputs];
}; // class DownstreamElementFixed

template<typename PacketType>
class DownstreamElement : public DownstreamElementBase<PacketType> {
public:
    typedef typename DownstreamElementBase<PacketType>::InputElement InputElement;

    DownstreamElement(uint32 nports) {
        mInputPorts.resize(nports);
        for(uint32 i = 0;i < nports; i++)
            mInputPorts[i].element = NULL;
    };

protected:
    typedef typename DownstreamElementBase<PacketType>::InputPort InputPort;

    virtual InputPort& input(uint32 k) {
        assert(k < mInputPorts.size());
        return mInputPorts[k];
    }

    std::vector<InputPort> mInputPorts;
}; // class DownstreamElement


template<typename PacketType>
class UpstreamElementBase {
public:
    typedef DownstreamElementBase<PacketType> OutputElement;

    virtual ~UpstreamElementBase() {}

    virtual bool connect(uint32 outport, OutputElement* elmt, uint32 inport) {
        OutputPort& o = output(outport);
        o.set(elmt, inport);
        elmt->connectInput(inport, this, outport);
        return true;
    }

    virtual PacketType* pull(uint32 port) = 0;

protected:
    class OutputPort {
    public:
        OutputPort()
         : element(NULL),
           port()
        {}

        bool set(OutputElement* elmt, uint32 _port) {
            element = elmt;
            port = _port;
            return true;
        }

        bool push(PacketType* pkt) {
            assert(element != NULL);
            return element->push(port, pkt);
        }

        OutputElement* element;
        uint32 port;
    };

    virtual OutputPort& output(uint32 k) = 0;
}; // class UpstreamElementBase

template<typename PacketType, uint32 NumOutputs>
class UpstreamElementFixed : public UpstreamElementBase<PacketType> {
public:
    typedef typename UpstreamElementBase<PacketType>::OutputElement OutputElement;

    UpstreamElementFixed() {
        memset(mOutputPorts, 0, sizeof(OutputPort)*NumOutputs);
    };

protected:
    typedef typename UpstreamElementBase<PacketType>::OutputPort OutputPort;

    virtual OutputPort& output(uint32 k) {
        assert(k < NumOutputs);
        return mOutputPorts[k];
    }

    OutputPort mOutputPorts[NumOutputs];
}; // class UpstreamElementFixed

template<typename PacketType>
class UpstreamElement : public UpstreamElementBase<PacketType> {
public:
    typedef typename UpstreamElementBase<PacketType>::OutputElement OutputElement;

    UpstreamElement(uint32 nports) {
        mOutputPorts.resize(nports);
        for(uint32 i = 0;i < nports; i++)
            mOutputPorts[i].element = NULL;
    };

protected:
    typedef typename UpstreamElementBase<PacketType>::OutputPort OutputPort;

    virtual OutputPort& input(uint32 k) {
        assert(k < mOutputPorts.size());
        return mOutputPorts[k];
    }

    std::vector<OutputPort> mOutputPorts;
}; // class UpstreamElement


template<typename PacketType>
class RouterElement : public DownstreamElement<PacketType>, public UpstreamElement<PacketType> {
public:
    typedef typename UpstreamElement<PacketType>::OutputElement OutputElement;
    typedef typename DownstreamElement<PacketType>::InputElement InputElement;
protected:
    typedef typename UpstreamElement<PacketType>::InputPort InputPort;
    typedef typename DownstreamElement<PacketType>::OutputPort OutputPort;
}; // class RouterElement


} // namespace Sirikata

#endif //_SIRIKATA_ROUTER_ELEMENT_