bulkDataNTConfiguration.h

Go to the documentation of this file.

#ifndef _BULK_DATA_NT_CONFIGURATION_H_
#define _BULK_DATA_NT_CONFIGURATION_H_

/*******************************************************************************
* ALMA - Atacama Large Millimiter Array
* (c) European Southern Observatory, 2011
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library 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
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA
*
* "@(#) $Id: bulkDataNTConfiguration.h,v 1.41 2013/01/18 07:47:50 bjeram Exp $"
*
* who       when        what
* --------  ---------   ----------------------------------------------
* rtobar    011-08-01   created
*/

#ifndef __cplusplus
#error This is a C++ include file and cannot be used from plain C
#endif

#include <map>
#include <string>

namespace AcsBulkdata
{

bool isBulkDataNTEnabled();

//  ... but can be later split if needed
class DDSConfiguration
{
        friend class BulkDataNTDDS;
        friend class BulkDataNTStream;
        friend class BulkDataNTDDSSubscriber;
        friend class BulkDataNTDDSPublisher;
        friend class BulkDataConfigurationParser;
public:
        DDSConfiguration();

        std::string getQosLibrary() const {     return libraryQos; }

        void setQosLibrary(std::string libraryQos) {            this->libraryQos = libraryQos;  }

        std::string getQosProfile() const {     return profileQos;      }

        void setQosProfile(std::string profileQos) {    this->profileQos = profileQos;  }

        static const char* const DEFAULT_LIBRARY;
        static const char* const DEFAULT_SENDER_STREAM_PROFILE;
        static const char* const DEFAULT_SENDER_FLOW_PROFILE;
        static const char* const DEFAULT_RECEIVER_STREAM_PROFILE;
        static const char* const DEFAULT_RECEIVER_FLOW_PROFILE;
        static const char* const DEFAULT_API_CREATE_PROFILE;
        static short debugLevel;

        std::string getStringProfileQoS() {
                return stringProfileQoS;
        }

protected:
        static void setDebugLevelFromEnvVar();
        static void setDDSLogVerbosity();
        std::string libraryQos;
        std::string profileQos;

        void setStringProfileQoS(char* cfg, const char* defaultProfile);
        void setStringProfileQoS(char* profileName, char* cfg,
                        const char* defaultProfile);
        std::string stringProfileQoS;
        // QoS that follow can be hardcoded, but is more flexible in this way.
        static bool ignoreUserProfileQoS; //when true USER_QOS_PROFILES.xml in current folder would not be loaded
        static bool ignoreEnvironmentProfileQoS; //when true NDDS_QOS_PROFILES will be ignored
        static unsigned int DDSLogVerbosity; // log level for RTI DDS, the type should be NDDS_Config_LogVerbosity
        static const char* const DEFAULT_QoS_FILE;
        static std::string urlProfileQoS;

        void fillUrlProfileQoS(const char*suffix=NULL);
        bool findProfileQoS(const char* path, const char*suffix=NULL);
};//DDSConfiguration


class StreamConfiguration : public DDSConfiguration
{
        friend class BulkDataNTStream;
        friend class BulkDataConfigurationParser;
public:
        StreamConfiguration();

        bool isParticipantPerStream() const {   return participantPerStream;    }
        void setParticipantPerStream(bool participantPerStream) {       this->participantPerStream = participantPerStream;      }

    static bool DEFAULT_PARTICIPANT_PER_STREAM;
protected:
        bool participantPerStream;  
};//StreamConfiguration


/****************************************/
/* Sender-side configuration structures */
/****************************************/

class  SenderFlowConfiguration : public DDSConfiguration
{
public:
        SenderFlowConfiguration();

        void setDDSSenderFlowQoS(char *cfg);

        void setDDSSenderFlowQoS(char *profileName, char* cfg);


        double getACKsTimeout() const;
    double getSendFrameTimeout() const;
    void setACKsTimeout(double acKsTimeout);
    void setSendFrameTimeout(double frameTimeout);
        double getThrottling() const;
        void setThrottling(double throttling);

    static double DEFAULT_SENDFRAME_TIMEOUT;
    static double DEFAULT_ACKs_TIMEOUT;

    static double DEFAULT_THROTTLING;
protected:
    double sendFrameTimeout;
        double ACKsTimeout;
        double throttling;
};

class SenderStreamConfiguration : public StreamConfiguration
{
public:
        SenderStreamConfiguration();

        void setDDSSenderStreamQoS(char *cfg);

        void setDDSSenderStreamQoS(char *profileName, char* cfg);


        //      std::map<const char *, BulkDataNTSenderFlowConfiguration> flows;
};


/******************************************/
/* Receiver-side configuration structures */
/******************************************/

enum ReceiverType {
        NORMAL    = 0x1,
        IMPORTANT = 0x2,
        CRITICAL  = 0x4
};

class ReceiverFlowConfiguration : public DDSConfiguration
{
public:
        ReceiverFlowConfiguration();

        void setDDSReceiverFlowQoS(char *cfg);

        void setDDSReceiverFlowQoS(char *profileName, char* cfg);

        double getCbReceiveProcessTimeout() const;
    void setCbReceiveProcessTimeout(double cbReceiveProcessTimeout);

    double getCbReceiveAvgProcessTimeout() const;
    void setCbReceiveAvgProcessTimeout(double cbReceiveAvgProcessTimeout);

    bool isEnableMulticast() const;
    void setEnableMulticast(bool enableMulticast);

    std::string getMulticastAddress() const;
    void setMulticastAddress(std::string multicastAddress);

    unsigned short getUnicastPort() const;
    void setUnicastPort(unsigned short);

    static const char* const DEFAULT_MULTICAST_ADDRESS;

    static double DEFAULT_CBRECEIVE_PROCESS_TIMEOUT;

    static double DEFAULT_CBRECEIVE_AVG_PROCESS_TIMEOUT;

    static bool DEFAULT_ENABLE_MULTICAST; 

    static unsigned short DEFAULT_UNICAST_PORT;  

protected:
    double cbReceiveProcessTimeout; 
    double cbReceiveAvgProcessTimeout; 
    bool enableMulticast; 
    std::string multicastAddress; 
    unsigned short unicastPort; 
};

class ReceiverStreamConfiguration : public StreamConfiguration
{
public:

        ReceiverStreamConfiguration();

        void setDDSReceiverStreamQoS(char *cfg);

        void setDDSReceiverStreamQoS(char *profileName, char* cfg);

        bool isUseIncrementUnicastPort() const { return useIncrementUnicastPort;        }
        void setUseIncrementUnicastPort(bool usePort) { this->useIncrementUnicastPort = usePort;}

        unsigned short getBaseUnicastPort() const {     return baseUnicastPort; }
        void setBaseUnicastPort(unsigned short port) { this->baseUnicastPort = port;    }

        static bool DEFAULT_USE_INCREMENT_UNICAST_PORT; 

        static unsigned short DEFAULT_BASE_UNICAST_PORT;  
protected:
        ReceiverType type;
        unsigned short baseUnicastPort;
        bool useIncrementUnicastPort; 
};//ReceiverStreamConfiguration

};

#endif