Globals.hpp

Go to the documentation of this file.

//******************************************************************************
// RCF - Remote Call Framework
//
// Copyright (c) 2005 - 2023, Delta V Software. All rights reserved.
// https://www.deltavsoft.com
//
// RCF is distributed under dual licenses - closed source or GPL.
// Consult your particular license for conditions of use.
//
// If you have not purchased a commercial license, you are using RCF under GPL terms.
//
// Version: 3.4
// Contact: support <at> deltavsoft.com 
//
//******************************************************************************


#ifndef INCLUDE_RCF_GLOBALS_HPP
#define INCLUDE_RCF_GLOBALS_HPP

#include <functional>
#include <string>

#include <RCF/Enums.hpp>
#include <RCF/Export.hpp>

namespace RCF {

    class ZlibDll;
    class OpenSslDll;
    class OpenSslCryptoDll;
    class RcfSession;
    class Exception;

    enum SslImplementation;

    class RCF_EXPORT Globals
    {

    public:
        Globals();
        ~Globals();

        void                setDefaultSslImplementation(SslImplementation sslImplementation);

        SslImplementation   getDefaultSslImplementation();

        void                setDefaultConnectTimeoutMs(unsigned int connectTimeoutMs);

        unsigned int        getDefaultConnectTimeoutMs();

        void                setDefaultRemoteCallTimeoutMs(unsigned int remoteCallTimeoutMs);

        unsigned int        getDefaultRemoteCallTimeoutMs();

        void                setZlibDllName(const std::string & dllName);

        std::string         getZlibDllName() const;

        void                setOpenSslDllName(const std::string & dllName);

        std::string         getOpenSslDllName() const;

        void                setOpenSslCryptoDllName(const std::string & dllName);

        std::string         getOpenSslCryptoDllName() const;

        // Sets the simultaneous publish limit. 
        // The publishing service issues messages asynchronously across all subscriber connections, and this setting controls how many asynchronous writes it can perform concurrently.
        void                setSimultaneousPublishLimit(std::size_t simultaneousPublishLimit);

        // Gets the simultaneous publish limit.
        std::size_t         getSimultaneousPublishLimit() const;

        // Default download directory for FileStream objects (deprecated).
        void                setFileStreamDefaultDownloadDirectory(const std::string & downloadDirectory);
        std::string         getFileStreamDefaultDownloadDirectory();


        ZlibDll &           getZlibDll();
        OpenSslDll &        getOpenSslDll();
        OpenSslCryptoDll &  getOpenSslCryptoDll();

        typedef std::function<
            void(
                const char * szFile, 
                int line, 
                const char * szFunc, 
                const Exception & e)> OnExceptionCallback;

        void                setOnExceptionCallback(OnExceptionCallback cb);
        OnExceptionCallback getOnExceptionCallback();

    private:

        void                releaseZlibDll();
        void                releaseOpenSslDll();
        void                releaseOpenSslCryptoDll();

        ZlibDll *           mpZlibDll;
        OpenSslDll *        mpOpenSslDll;
        OpenSslCryptoDll *  mpOpenSslCryptoDll;

        std::string         mZlibDllName;
        std::string         mOpenSslDllName;
        std::string         mOpenSslCryptoDllName;

        std::size_t         mSimultaneousPublishLimit;

        std::string         mFileStreamDefaultDownloadDirectory;

#if defined(RCF_WINDOWS) && RCF_FEATURE_OPENSSL==0
        // Windows builds without OpenSSL.
        SslImplementation   mDefaultSslImplementation = Si_Schannel;
#else
        // All other builds.
        SslImplementation   mDefaultSslImplementation = Si_OpenSsl;
#endif

        unsigned int        mClientConnectTimeoutMs = 1000 * 2;
        unsigned int        mClientRemoteCallTimeoutMs = 1000 * 10;

        OnExceptionCallback mOnExceptionCallback;
    };


    RCF_EXPORT Globals & globals();


} // namespace RCF

#endif // ! INCLUDE_RCF_GLOBALS_HPP