ServiceProperty.hpp

 
#ifndef RTI_CDS_CLOUD_DISCOVERY_SERVICE_PROPERTY_HPP_
#define RTI_CDS_CLOUD_DISCOVERY_SERVICE_PROPERTY_HPP_
 
#include <dds/core/macros.hpp>
#include <rti/core/NativeValueType.hpp>
 
#include "clouddiscoveryservice/clouddiscoveryservice_infrastructure.h"
#include "clouddiscoveryservice/clouddiscoveryservice_service.h"
 
namespace rti { namespace cds {
 
class DomainListProperty {
public:
    DomainListProperty() : allow_domain_ids_(""), deny_domain_ids_("")
    {
    }
 
    DomainListProperty(std::string allow_domain_ids, std::string deny_domain_ids)
    {
        allow_domain_ids_ = allow_domain_ids;
        deny_domain_ids_ = deny_domain_ids;
    }
 
    void allow_domain_ids(std::string allow_domain_ids)
    {
        allow_domain_ids_ = allow_domain_ids;
    }
 
    std::string& allow_domain_ids()
    {
        return allow_domain_ids_;
    }
 
    void deny_domain_ids(std::string deny_domain_ids)
    {
        deny_domain_ids_ = deny_domain_ids;
    }
 
    std::string& deny_domain_ids()
    {
        return deny_domain_ids_;
    }
 
private:
    std::string allow_domain_ids_;
    std::string deny_domain_ids_;
};
 
class TransportUnicastProperty {
public:
    TransportUnicastProperty(std::string alias, int receive_port)
    {
        alias_ = alias;
        receive_port_ = receive_port;
    }
 
    void alias(std::string alias)
    {
        alias_ = alias;
    }
 
    std::string& alias()
    {
        return alias_;
    }
 
    void receive_port(int receive_port)
    {
        receive_port_ = receive_port;
    }
 
    int receive_port()
    {
        return receive_port_;
    }
 
private:
    std::string alias_;
    int receive_port_;
};
 
class PropertyAdapter {
public:
    typedef RTI_CDS_Property native_type;
 
    static void initialize(native_type& native_value)
    {
        static const native_type DEFAULT
                = RTI_CDS_Property_INITIALIZER;
        native_value = DEFAULT;
        // Replicating the defaults from the C Library API as specified in service.ifc
        native_value.service_verbosity = RTI_LOG_BIT_EXCEPTION;
        native_value.dds_verbosity = RTI_LOG_BIT_EXCEPTION;
    }
 
    static void finalize(native_type& native_value)
    {
        if (native_value.cfg_strings != NULL) {
            RTIOsapiHeap_freeArray(native_value.cfg_strings);
            native_value.cfg_strings = NULL;
        }
 
        RTI_CDS_Property_finalize(&native_value);
    }
 
    static void copy(native_type& destination, const native_type& source)
    {
        if (RTI_CDS_Property_copy(&destination, &source) == NULL) {
            throw dds::core::Error("Native RTI_CDS_Property_copy");
        }
    }
 
    static bool equals(const native_type& first, const native_type& second)
    {
        RTIOsapiUtility_unusedParameter(first);
        RTIOsapiUtility_unusedParameter(second);
 
        throw dds::core::UnsupportedError("Unsupported operation: equals");
    }
 
    static void add_transports_from_native(
            std::vector<TransportUnicastProperty>& transport_selection,
            const struct RTI_CDS_TransportSelectionProperty *transport_selection_native)
    {
        for (int i = 0; i < transport_selection_native->count; i++) {
            transport_selection.push_back(TransportUnicastProperty(
                    transport_selection_native->transports[i].alias,
                    transport_selection_native->transports[i].receive_port));
        }
    }
 
    static void add_transports_to_native(
            struct RTI_CDS_TransportSelectionProperty *transport_selection_native,
            std::vector<TransportUnicastProperty>& transport_selection)
    {
        transport_selection_native->count = transport_selection.size();
        for (unsigned int i = 0; i < transport_selection.size(); i++) {
            RTIOsapiUtility_strcpy(
                    transport_selection_native->transports[i].alias,
                    RTI_CDS_TRANSPORT_UNICAST_PROPERTY_ALIAS_LENGTH_MAX,
                    transport_selection[i].alias().c_str());
            transport_selection_native->transports[i].receive_port
                    = transport_selection[i].receive_port();
        }
    }
 
    static void add_domain_list_from_native(
            DomainListProperty& domain_ids,
            const struct RTI_CDS_DomainListProperty *domain_ids_native)
    {
        domain_ids.allow_domain_ids(domain_ids_native->allow_domain_ids);
        domain_ids.deny_domain_ids(domain_ids_native->deny_domain_ids);
    }
 
    static void add_domain_list_to_native(
            struct RTI_CDS_DomainListProperty *domain_ids_native,
            DomainListProperty& domain_ids)
    {
        DDS_String_replace(
                &domain_ids_native->allow_domain_ids,
                domain_ids.allow_domain_ids().c_str());
        DDS_String_replace(
                &domain_ids_native->deny_domain_ids,
                domain_ids.deny_domain_ids().c_str());
    }
 
    static void add_properties_from_native(
            std::map<std::string, std::string>& properties,
            const RTI_RoutingServiceProperties *native_properties)
    {
        for (int i = 0; i < native_properties->count; i++) {
            properties[native_properties->properties[i].name] =
                    (const char *) native_properties->properties[i].value;
        }
    }
 
    static void add_properties_to_native(
            RTI_RoutingServiceProperties *native_properties,
            const std::map<std::string, std::string>& properties)
    {
        RTI_RoutingServiceProperties_finalize(native_properties);
        if (!RTI_RoutingServiceProperties_initialize(native_properties)) {
            throw dds::core::Error("failed to initialize native property");
        }
 
        std::map<std::string, std::string>::const_iterator it = properties.begin();
        for (; it != properties.end(); ++it) {
            if (!RTI_RoutingServiceProperties_add(
                    native_properties,
                    it->first.c_str(),
                    it->second.c_str())) {
                throw dds::core::Error("failed to add native property");
            }
        }
    }
};
 
class ServiceProperty;
 
}
 
namespace core {
 
template<>
struct native_type_traits<rti::cds::ServiceProperty> {
    typedef rti::cds::PropertyAdapter adapter_type;
    typedef RTI_CDS_Property native_type;
};
 
}
 
namespace cds {
 
class ServiceProperty : public rti::core::NativeValueType<ServiceProperty>
{
public:
    RTI_NATIVE_VALUE_TYPE_DEFINE_DEFAULT_MOVE_OPERATIONS(ServiceProperty)
 
    typedef rti::core::NativeValueType<ServiceProperty> Base;
 
    ServiceProperty(): Base()
    {
    }
 
    ServiceProperty(const struct RTI_CDS_Property &native_property)
            : Base(native_property)
    {
    }
 
    std::string cfg_file() const
    {
        return native().cfg_file == NULL ? "" : native().cfg_file;
    }
 
    ServiceProperty& cfg_file(const std::string& filename)
    {
        DDS_String_replace(
                &native().cfg_file,
                filename.c_str());
        return *this;
    }
 
    const std::vector<std::string>& cfg_strings() const
    {
        return cfg_strings_;
    }
 
    ServiceProperty& cfg_strings(
            const std::vector<std::string>& the_cfg_strings)
    {
        cfg_strings_ = the_cfg_strings;
        if (cfg_strings_.size() > 0) {
            if (!RTIOsapiHeap_reallocateArray(
                    (char ***) &native().cfg_strings,
                    cfg_strings_.size(),
                    char *)) {
                throw dds::core::OutOfResourcesError("cfg_strings native array");
            }
 
            for (uint32_t i = 0; i < cfg_strings_.size(); i++) {
                native().cfg_strings[i] = cfg_strings_[i].c_str();
            }
        }
        native().cfg_strings_count = static_cast<int>(cfg_strings_.size());
 
        return *this;
    }
 
    std::string service_name() const
    {
        return native().service_name == NULL ? "" : native().service_name;
    }
 
    ServiceProperty& service_name(const std::string& name)
    {
        DDS_String_replace(&native().service_name, name.c_str());
        return *this;
    }
 
    std::string application_name() const
    {
        return native().application_name == NULL ? "" : native().application_name;
    }
 
    ServiceProperty& application_name(const std::string& name)
    {
        DDS_String_replace(&native().application_name, name.c_str());
        return *this;
    }
 
    bool enforce_xsd_validation() const
    {
        return (native().enforce_xsd_validation == DDS_BOOLEAN_TRUE)
                ? true
                : false;
    }
 
    ServiceProperty& enforce_xsd_validation(const bool enforce_xsd_validation)
    {
        native().enforce_xsd_validation = enforce_xsd_validation;
        return *this;
    }
 
    bool skip_default_files() const
    {
        return (native().skip_default_files == DDS_BOOLEAN_TRUE)
                ? true
                : false;
    }
 
    ServiceProperty& skip_default_files(const bool& skip)
    {
        native().skip_default_files = skip
                ? DDS_BOOLEAN_TRUE
                : DDS_BOOLEAN_FALSE;
        return *this;
    }
 
    std::vector<TransportUnicastProperty> transport_selection()
    {
        PropertyAdapter::add_transports_from_native(
                transport_selection_,
                &native().transport_selection);
 
        return transport_selection_;
    }
 
    ServiceProperty& transport_selection(
            const std::vector<TransportUnicastProperty>& transport_selection)
    {
        transport_selection_ = transport_selection;
        PropertyAdapter::add_transports_to_native(
                &native().transport_selection,
                transport_selection_);
 
        return *this;
    }
 
    DomainListProperty domain_list()
    {
        PropertyAdapter::add_domain_list_from_native(
                domain_list_,
                &native().domain_list);
 
        return domain_list_;
    }
 
    ServiceProperty& domain_list(
            const DomainListProperty& domain_list)
    {
        domain_list_ = domain_list;
        PropertyAdapter::add_domain_list_to_native(
                &native().domain_list,
                domain_list_);
 
        return *this;
    }
 
    bool enable_administration() const
    {
        return (native().enable_administration == DDS_BOOLEAN_TRUE)
                ? true
                : false;
    }
 
    ServiceProperty& enable_administration(const bool enable)
    {
        native().enable_administration = enable
                ? DDS_BOOLEAN_TRUE
                : DDS_BOOLEAN_FALSE;
        return *this;
    }
 
    int administration_domain_id() const
    {
        return native().administration_domain_id;
    }
 
    ServiceProperty& administration_domain_id(const int domain_id)
    {
        native().administration_domain_id = domain_id;
        return *this;
    }
 
    bool enable_monitoring() const
    {
        return (native().enable_monitoring == DDS_BOOLEAN_TRUE)
                ? true
                : false;
    }
 
    ServiceProperty& enable_monitoring(const bool enable)
    {
        native().enable_monitoring = enable
                ? DDS_BOOLEAN_TRUE
                : DDS_BOOLEAN_FALSE;
        return *this;
    }
 
    int monitoring_domain_id() const
    {
        return native().monitoring_domain_id;
    }
 
    ServiceProperty& monitoring_domain_id(const int domain_id)
    {
        native().monitoring_domain_id = domain_id;
        return *this;
    }
 
    std::string license_file_name() const
    {
        return native().license_file_name == NULL
                ? ""
                : native().license_file_name;
    }
 
    ServiceProperty& license_file_name(const std::string& file_name)
    {
        DDS_String_replace(
                &native().license_file_name,
                file_name.c_str());
        return *this;
    }
 
    std::map<std::string, std::string> user_environment() const
    {
        std::map<std::string, std::string> properties;
 
        PropertyAdapter::add_properties_from_native(
                properties,
                &native().user_environment);
 
        return properties;
    }
 
    ServiceProperty& user_environment(
            const std::map<std::string, std::string>& user_environment)
    {
        PropertyAdapter::add_properties_to_native(
                &native().user_environment,
                user_environment);
 
        return *this;
    }
 
private:
    std::vector<std::string> cfg_strings_;
    std::vector<TransportUnicastProperty> transport_selection_;
    DomainListProperty domain_list_;
 
};
 
}}
 
#endif // RTI_CDS_CLOUD_DISCOVERY_SERVICE_PROPERTY_HPP_