DataPort.h

/***************************************************************************
 * \file DataPort.h
 * \brief Defines the basic 10GigE data port interface for an
 *    NDR-class radio.
 * \author DA
 * \author NH
 * \author MN
 * \copyright (c) 2017 CyberRadio Solutions, Inc.  All rights reserved.
 *
 ***************************************************************************/
 
#ifndef INCLUDED_LIBCYBERRADIO_DRIVER_DATAPORT_H
#define INCLUDED_LIBCYBERRADIO_DRIVER_DATAPORT_H
 
#include "LibCyberRadio/Driver/Configurable.h"
#include "LibCyberRadio/Common/BasicDict.h"
#include "LibCyberRadio/Common/BasicList.h"
#include <string>
 

namespace LibCyberRadio
{
    namespace Driver
    {
        // Forward declaration for RadioHandler object
        class RadioHandler;

        class DataPort : public Configurable
        {
            public:
                DataPort(const std::string& name = "DATAPORT",
                        int index = 0,
                        RadioHandler* parent = NULL,
                        bool debug = false,
                        const std::string& sourceIP = "0.0.0.0",
                        int numDataPortDipEntries = 0,
                        int dataPortDipEntryIndexBase = 0);
                virtual ~DataPort();
                DataPort(const DataPort& other);
                virtual DataPort& operator=(const DataPort& other);
                // Configurable interface
                virtual bool setConfiguration(ConfigurationDict& cfg);
                virtual void queryConfiguration();
                // DataPort extensions
                virtual int getNumDestEntries() const;
                virtual BasicIntList getDestEntryIndexRange() const;
                virtual std::string getSourceIP() const;
                virtual bool setSourceIP(const std::string& ipAddr);
                virtual std::string getDestMACAddress(int dipIndex) const;
                virtual std::string getDestIPAddress(int dipIndex) const;
                virtual unsigned int getDestSourcePort(int dipIndex) const;
                virtual unsigned int getDestDestPort(int dipIndex) const;
                virtual bool setDestInfo(int dipIndex,
                        const std::string& ipAddr,
                        const std::string& macAddr,
                        unsigned int sourcePort,
                        unsigned int destPort);
                virtual bool setDestMACAddress(int dipIndex, const std::string& macAddr);
                virtual bool setDestIPAddress(int dipIndex, const std::string& ipAddr);
                virtual bool setDestSourcePort(int dipIndex, unsigned int sourcePort);
                virtual bool setDestDestPort(int dipIndex, unsigned int destPort);
                virtual bool enableErrors(bool enabled = true);
                virtual bool disableErrors();
                virtual bool enableFlowControl(bool enabled = true);
                virtual bool disableFlowControl();
 
            protected:
                // Configurable interface
                virtual void initConfigurationDict();
                virtual void updateConfigurationDict();
                // DataPort extensions
                virtual bool executeSourceIPQuery(int index, std::string& ipAddr);
                virtual bool executeSourceIPCommand(int index, std::string& ipAddr);
                virtual bool executeDestIPQuery(int index,
                        int dipIndex,
                        std::string& ipAddr,
                        std::string& macAddr,
                        unsigned int& sourcePort,
                        unsigned int& destPort);
                virtual bool executeDestIPCommand(int index,
                        int dipIndex,
                        std::string& ipAddr,
                        std::string& macAddr,
                        unsigned int& sourcePort,
                        unsigned int& destPort);
                virtual bool executeErrorEnabledQuery(int index, bool& enabled);
                virtual bool executeErrorEnabledCommand(int index, bool& enabled);
                virtual bool executeFlowControlEnabledQuery(int index, bool& enabled);
                virtual bool executeFlowControlEnabledCommand(int index, bool& enabled);
 
            protected:
                // Index number of the data port
                int _index;
                // Parent radio handler object
                RadioHandler* _parent;
                // Source IP address
                std::string _sourceIP;
                // Number of DIP table entries
                int _numDipEntries;
                // DIP entry index base
                int _dipEntryIndexBase;
                // Whether errors are enabled or not
                bool _errorsEnabled;
                // Whether flow control is enabled or not
                bool _flowControlEnabled;
                // Dict of MAC addresses, keyed by DIP table index
                BasicIntStringDict _macAddresses;
                // Dict of IP addresses, keyed by DIP table index
                BasicIntStringDict _ipAddresses;
                // Dict of source UDP port numbers, keyed by DIP table index
                BasicIntUIntDict _sourcePorts;
                // Dict of destination UDP port numbers, keyed by DIP table index
                BasicIntUIntDict _destPorts;
 
 
        }; /* class DataPort */

        typedef BASIC_DICT_CONTAINER<int, DataPort*> DataPortDict;
 
    } /* namespace Driver */
 
} /* namespace LibCyberRadio */
 
#endif /* INCLUDED_LIBCYBERRADIO_DRIVER_DATAPORT_H0 */