InitializationParameters.h

/*-----------------------------------------------------------------------
Licensed to the Apache Software Foundation (ASF) under one
or more contributor license agreements.  See the NOTICE file
distributed with this work for additional information
regarding copyright ownership.  The ASF licenses this file
to you under the Apache License, Version 2.0 (the
"License"; you may not use this file except in compliance
with the License.  You may obtain a copy of the License at
 
  http://www.apache.org/licenses/LICENSE-2.0
 
Unless required by applicable law or agreed to in writing,
software distributed under the License is distributed on an
"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
KIND, either express or implied.  See the License for the
specific language governing permissions and limitations
under the License.
-----------------------------------------------------------------------*/
#pragma once
 
#include <boost/uuid/uuid_io.hpp>
 
#include "../nsDefinitions.h"
#include "EtpMessages.h"
 
#if defined(_WIN32) && !defined(FETPAPI_STATIC)
#ifndef FETPAPI_DLL_IMPORT_OR_EXPORT
#if defined(Fetpapi_EXPORTS)
#define FETPAPI_DLL_IMPORT_OR_EXPORT __declspec(dllexport)
#else
#define FETPAPI_DLL_IMPORT_OR_EXPORT __declspec(dllimport)
#endif
#endif
#else
#define FETPAPI_DLL_IMPORT_OR_EXPORT
#endif
 
namespace ETP_NS
{
    class InitializationParameters
    {
    private:
        void initFromUrl(const std::string& etpUrl, const std::string& proxyUrl);
 
    protected:
        boost::uuids::uuid identifier;
        std::string etpServerHost;
        uint16_t etpServerPort;
        std::string etpServerUrlPath;
        std::string proxyHost;
        uint16_t proxyPort;
        std::map<std::string, std::string> additionalHandshakeHeaderFields;
        std::string additionalCertificates;
        bool forceTls = false;
 
        uint64_t preferredMaxFrameSize = 4096;
 
        uint64_t maxWebSocketMessagePayloadSize = 16000000;
 
    public:
 
        FETPAPI_DLL_IMPORT_OR_EXPORT InitializationParameters(boost::uuids::uuid instanceUuid,
            const std::string& etpServerUrl, const std::string& proxyUrl = "")
        {
            initFromUrl(etpServerUrl, proxyUrl);
            identifier = instanceUuid;
        }
        FETPAPI_DLL_IMPORT_OR_EXPORT InitializationParameters(boost::uuids::uuid instanceUuid, {…}
 
        FETPAPI_DLL_IMPORT_OR_EXPORT InitializationParameters(const std::string& instanceUuid,
            const std::string& etpServerUrl, const std::string& proxyUrl = "")
        {
            initFromUrl(etpServerUrl, proxyUrl);
            std::stringstream ss(instanceUuid);
            ss >> identifier;
        }
        FETPAPI_DLL_IMPORT_OR_EXPORT InitializationParameters(const std::string& instanceUuid, {…}
 
        InitializationParameters(boost::uuids::uuid instanceUuid,
            const std::string& host, uint16_t port, const std::string& urlPath = "") :
            identifier(instanceUuid), etpServerHost(host), etpServerPort(port), etpServerUrlPath(urlPath)
        {}
        InitializationParameters(boost::uuids::uuid instanceUuid, {…}
        
        InitializationParameters(const std::string & instanceUuid,
            const std::string& host, uint16_t port, const std::string& urlPath = "") :
            etpServerHost(host), etpServerPort(port), etpServerUrlPath(urlPath)
        {
            std::stringstream ss(instanceUuid);
            ss >> identifier;
        }
        InitializationParameters(const std::string & instanceUuid, {…}
 
        virtual ~InitializationParameters() = default;
 
        FETPAPI_DLL_IMPORT_OR_EXPORT void setMaxWebSocketMessagePayloadSize(uint64_t value) { maxWebSocketMessagePayloadSize = value; }
        FETPAPI_DLL_IMPORT_OR_EXPORT uint64_t getMaxWebSocketMessagePayloadSize() const { return maxWebSocketMessagePayloadSize; }
 
        FETPAPI_DLL_IMPORT_OR_EXPORT void setPreferredMaxFrameSize(uint64_t value) { preferredMaxFrameSize = value; }
        FETPAPI_DLL_IMPORT_OR_EXPORT uint64_t getPreferredMaxFrameSize() const { return preferredMaxFrameSize; }
 
        FETPAPI_DLL_IMPORT_OR_EXPORT void setAdditionalHandshakeHeaderFields(const std::map<std::string, std::string>& extraHandshakeHeaderFields)
            { this->additionalHandshakeHeaderFields = extraHandshakeHeaderFields; }
        FETPAPI_DLL_IMPORT_OR_EXPORT const std::map<std::string, std::string>& getAdditionalHandshakeHeaderFields() const { return additionalHandshakeHeaderFields; }
 
        FETPAPI_DLL_IMPORT_OR_EXPORT void setAdditionalCertificates(const std::string& extraCertificates) { this->additionalCertificates = extraCertificates; }
        FETPAPI_DLL_IMPORT_OR_EXPORT const std::string& getAdditionalCertificates() const { return additionalCertificates; }
 
        FETPAPI_DLL_IMPORT_OR_EXPORT const boost::uuids::uuid& getInstanceId() const { return identifier; }
        
        FETPAPI_DLL_IMPORT_OR_EXPORT const std::string& getEtpServerHost() const { return etpServerHost; }
        FETPAPI_DLL_IMPORT_OR_EXPORT uint16_t getEtpServerPort() const { return etpServerPort; }
        FETPAPI_DLL_IMPORT_OR_EXPORT const std::string& getEtpServerUrlPath() const { return etpServerUrlPath; }
 
        FETPAPI_DLL_IMPORT_OR_EXPORT const std::string& getProxyHost() const { return proxyHost; }
        FETPAPI_DLL_IMPORT_OR_EXPORT uint16_t getProxyPort() const { return proxyPort; }
 
        FETPAPI_DLL_IMPORT_OR_EXPORT void setForceTls(bool force) { forceTls = force; }
        FETPAPI_DLL_IMPORT_OR_EXPORT bool isTlsForced() const { return forceTls; }
 
        FETPAPI_DLL_IMPORT_OR_EXPORT virtual std::string getApplicationName() const { return "F2I-CONSULTING ETP CLIENT"; }
        FETPAPI_DLL_IMPORT_OR_EXPORT virtual std::string getApplicationVersion() const { return "0.0"; }
 
        FETPAPI_DLL_IMPORT_OR_EXPORT std::map<std::string, Energistics::Etp::v12::Datatypes::DataValue> makeEndpointCapabilities() const;
        FETPAPI_DLL_IMPORT_OR_EXPORT virtual std::vector<Energistics::Etp::v12::Datatypes::SupportedDataObject> makeSupportedDataObjects() const;
        FETPAPI_DLL_IMPORT_OR_EXPORT virtual std::vector<Energistics::Etp::v12::Datatypes::SupportedProtocol> makeSupportedProtocols() const;
 
        FETPAPI_DLL_IMPORT_OR_EXPORT virtual void postSessionCreationOperation(class AbstractSession* session) const;
    };
    class InitializationParameters {…};
}