ServiceProperty.hpp

/*
 * $Id$
 *
 * (c) Copyright, Real-Time Innovations, 2016-.
 * All rights reserved.
 * No duplications, whole or partial, manual or electronic, may be made
 * without express written permission.  Any such copies, or
 * revisions thereof, must display this notice unaltered.
 * This code contains trade secrets of Real-Time Innovations, Inc.
 */

#ifndef HPP_SERVICE_SERVICEPROPERTY_HPP_
#define HPP_SERVICE_SERVICEPROPERTY_HPP_

#include "stdio.h"
#include "stdlib.h"
#include <string>
#include <stdint.h>
#include <map>

#include "osapi/osapi_type.h"

#include "routingservice/routingservice_infrastructure.h"
#include "routingservice/routingservice_service.h"

#include <dds/core/SafeEnumeration.hpp>
#include <rti/recording/PropertySet.hpp>

namespace rti { namespace recording {

struct ApplicationRoleKind_def {
    enum type {
        RECORD_APPLICATION,
        REPLAY_APPLICATION,
        CONVERTER_APPLICATION,
        /*i
         * @brief Internal use only
         */
        XML_CONVERTER_APPLICATION,
        /*i
         * @brief Indexer mode. To be used internally by our command-line tool.
         */
        INDEX_APPLICATION,
        /*i
         */
        count_
    };
};

typedef dds::core::safe_enum<ApplicationRoleKind_def> ApplicationRoleKind;

/*i
 * @brief Internal use only
 */
struct XmlConverterRoleKind_def {

    enum type {
        RECORD_CONVERT,
        REPLAY_CONVERT,
        count_
    };
};

typedef dds::core::safe_enum<XmlConverterRoleKind_def> XmlConverterRoleKind;

/*i
 * @brief Indexer mode enumeration, used by the index application (offline
 * indexing)
 */
struct IndexerModeKind_def {

    enum type {
        INSTANCE_INDEXING,
        SQLITE_INDEXING,
        count_
    };
};
typedef dds::core::safe_enum<IndexerModeKind_def> IndexerModeKind;

typedef rti::routing::PropertySet PropertySet;

class ServiceProperty {
public:
    ServiceProperty() :
        cfg_file_(""),
        service_name_(""),
        application_name_(""),
        domain_id_base_(0),
        enable_administration_(false),
        administration_domain_id_(0),
        enable_monitoring_(false),
        monitoring_domain_id_(0),
        application_role_(ApplicationRoleKind::RECORD_APPLICATION),
        enforce_xsd_validation_(true),
        ignore_default_files_(false),
        output_cfg_file_(""),
        debug_mode_(false),
        xml_converter_role_(XmlConverterRoleKind::RECORD_CONVERT),
        indexer_mode_(IndexerModeKind::INSTANCE_INDEXING)

    {

    }

    const std::string& cfg_file() const
    {
        return cfg_file_;
    }

    ServiceProperty& cfg_file(const std::string & cfg_file)
    {
        cfg_file_ = cfg_file;

        return *this;
    }

    const std::string & service_name() const
    {
        return service_name_;
    }

    ServiceProperty& service_name(const std::string & service_name)
    {
        service_name_ = service_name;

        return *this;
    }

    const std::string & application_name() const
    {
        return application_name_;
    }

    ServiceProperty& application_name(const std::string & application_name)
    {
        application_name_ = application_name;

        return *this;
    }


    int32_t domain_id_base() const
    {
        return domain_id_base_;
    }

    bool enforce_xsd_validation() const
    {
        return enforce_xsd_validation_;
    }

    ServiceProperty& enforce_xsd_validation(bool enforce)
    {
        enforce_xsd_validation_ = enforce;

        return *this;
    }

    ServiceProperty& domain_id_base(int32_t domain_id)
    {
        domain_id_base_ = domain_id;

        return *this;
    }

    bool enable_administration() const
    {
        return enable_administration_;
    }

    ServiceProperty& enable_administration(bool enable_administration)
    {
        enable_administration_ = enable_administration;

        return *this;
    }

    int32_t administration_domain_id() const
    {
        return administration_domain_id_;
    }

    ServiceProperty& administration_domain_id(int32_t domain_id)
    {
        administration_domain_id_ = domain_id;

        return *this;
    }

    bool enable_monitoring() const
    {
        return enable_monitoring_;
    }

    ServiceProperty& enable_monitoring(bool enable_monitoring)
    {
        enable_monitoring_ = enable_monitoring;
        return *this;
    }

    int32_t monitoring_domain_id() const
    {
        return monitoring_domain_id_;
    }

    ServiceProperty& monitoring_domain_id(int32_t domain_id)
    {
        monitoring_domain_id_ = domain_id;
        return *this;
    }

    const ApplicationRoleKind& application_role() const
    {
        return application_role_;
    }

    ServiceProperty& application_role(ApplicationRoleKind application_role)
    {
        application_role_ = application_role;
        return *this;
    }

    bool ignore_default_files() const
    {
        return ignore_default_files_;
    }

    ServiceProperty& ignore_default_files(bool ignore)
    {
        ignore_default_files_ = ignore;
        return *this;
    }

    const std::string& license_file() const
    {
        return license_file_;
    }

    ServiceProperty& license_file(const std::string& license_file)
    {
        license_file_ = license_file;
        return *this;
    }

    /*i
     * @brief Internal use only
     */
    const std::string output_cfg_file() const
    {
        return output_cfg_file_;
    }

    /*i
     * @brief Internal use only
     */
    ServiceProperty& output_cfg_file(
            const std::string & output_cfg_file)
    {
        output_cfg_file_ = output_cfg_file;
        return *this;
    }

    bool debug_mode() const
    {
        return debug_mode_;
    }

    ServiceProperty& debug_mode(bool debug_mode)
    {
        debug_mode_ = debug_mode;

        return *this;
    }

    /*i
     * @brief Internal use only
     */
    XmlConverterRoleKind xml_converter_role() const
    {
        return xml_converter_role_;
    }

    /*i
     * @brief Internal use only
     */
    ServiceProperty& xml_converter_role(
            const XmlConverterRoleKind & xml_converter_role)
    {
        xml_converter_role_ = xml_converter_role;
        return *this;
    }

    /*i
     * @brief The indexer application mode. Defined by the IndexerModeKind.
     * Internal use only
     */
    IndexerModeKind indexer_mode() const
    {
        return indexer_mode_;
    }

    /*i
     * @brief Set the indexer application mode. Defined by the IndexerModeKind.
     * Internal use only
     */
    ServiceProperty& indexer_mode(const IndexerModeKind& indexer_mode)
    {
        indexer_mode_ = indexer_mode;
        return *this;
    }

    /*i
     * @brief The indexer database directory.
     * Internal use only
     */
    const std::string& db_directory() const
    {
        return db_directory_;
    }

    /*i
     * @brief Set the indexer database directory.
     * Internal use only
     */
    ServiceProperty& db_directory(const std::string& db_directory)
    {
        db_directory_ = db_directory;
        return *this;
    }

    const PropertySet& user_environment() const
    {
        return user_env_;
    }

    PropertySet& user_environment()
    {
        return user_env_;
    }

    ServiceProperty& user_environment(const PropertySet& user_environment)
    {
        user_env_ = user_environment;

        return *this;
    }

private:
    std::string cfg_file_;
    //std::string cfg_strings[] ?
    std::string service_name_;
    std::string application_name_;
    int32_t domain_id_base_;
    bool enable_administration_;
    int32_t administration_domain_id_;
    bool enable_monitoring_;
    int32_t monitoring_domain_id_;
    ApplicationRoleKind application_role_;
    bool enforce_xsd_validation_;
    bool ignore_default_files_;
    std::string license_file_;
    // Specific to XML conversion
    std::string output_cfg_file_;
    bool debug_mode_;
    XmlConverterRoleKind xml_converter_role_;
    IndexerModeKind indexer_mode_;
    std::string db_directory_;
    PropertySet user_env_;
};


} } /* namespace rti::recording */

#endif /* HPP_SERVICE_SERVICEPROPERTY_HPP_ */