Initialize.h

Go to the documentation of this file.

//
// Copyright (c) ZeroC, Inc. All rights reserved.
//
 
#ifndef ICE_INITIALIZE_H
#define ICE_INITIALIZE_H
 
#include <IceUtil/Timer.h>
#include <Ice/Communicator.h>
#include <Ice/PropertiesF.h>
#include <Ice/InstanceF.h>
#include <Ice/LoggerF.h>
#include <Ice/InstrumentationF.h>
#include <Ice/Dispatcher.h>
#include <Ice/FactoryTable.h>
#include <Ice/BuiltinSequences.h>
#include <Ice/Version.h>
#include <Ice/Plugin.h>
#include <Ice/BatchRequestInterceptor.h>
 
#ifdef ICE_CPP11_MAPPING
#   define ICE_CONFIG_FILE_STRING const std::string&
#else
#   define ICE_CONFIG_FILE_STRING const char*
#endif
 
namespace Ice
{
 
ICE_API StringSeq argsToStringSeq(int argc, const char* const argv[]);
 
#ifdef _WIN32
 
ICE_API StringSeq argsToStringSeq(int argc, const wchar_t* const argv[]);
#endif
 
ICE_API void stringSeqToArgs(const StringSeq& seq, int& argc, const char* argv[]);
 
inline void stringSeqToArgs(const StringSeq& seq, int& argc, char* argv[])
{
    return stringSeqToArgs(seq, argc, const_cast<const char**>(argv));
}
 
#ifdef _WIN32
 
ICE_API void stringSeqToArgs(const StringSeq& seq, int& argc, const wchar_t* argv[]);
 
inline void stringSeqToArgs(const StringSeq& seq, int& argc, wchar_t* argv[])
{
    return stringSeqToArgs(seq, argc, const_cast<const wchar_t**>(argv));
}
#endif
 
ICE_API PropertiesPtr createProperties();
 
ICE_API PropertiesPtr createProperties(StringSeq& seq, const PropertiesPtr& defaults = 0);
 
ICE_API PropertiesPtr createProperties(int& argc, const char* argv[], const PropertiesPtr& defaults = 0);
 
inline PropertiesPtr createProperties(int& argc, char* argv[], const PropertiesPtr& defaults = 0)
{
    return createProperties(argc, const_cast<const char**>(argv), defaults);
}
 
#ifdef _WIN32
 
ICE_API PropertiesPtr createProperties(int& argc, const wchar_t* argv[], const PropertiesPtr& defaults = 0);
 
inline PropertiesPtr createProperties(int& argc, wchar_t* argv[], const PropertiesPtr& defaults = 0)
{
    return createProperties(argc, const_cast<const wchar_t**>(argv), defaults);
}
#endif
 
class ICE_API ThreadNotification : public IceUtil::Shared
{
public:
 
    virtual void start() = 0;
 
    virtual void stop() = 0;
};
 
typedef IceUtil::Handle<ThreadNotification> ThreadNotificationPtr;
 
class ICE_API ThreadHookPlugin : public Ice::Plugin
{
public:
 
#ifdef ICE_CPP11_MAPPING
 
    ThreadHookPlugin(const CommunicatorPtr& communicator, std::function<void()> start, std::function<void()> stop);
#else
 
    ThreadHookPlugin(const CommunicatorPtr& communicator, const ThreadNotificationPtr& hook);
#endif
 
    virtual void initialize();
 
    virtual void destroy();
};
 
struct InitializationData
{
    PropertiesPtr properties;
 
    LoggerPtr logger;
 
    Instrumentation::CommunicatorObserverPtr observer;
 
#ifdef ICE_CPP11_MAPPING
 
#if defined(__clang__)
#   pragma clang diagnostic push
#   pragma clang diagnostic ignored "-Wdocumentation" // param/return is not recognized for std::function data members
#endif
 
    std::function<void()> threadStart;
 
    std::function<void()> threadStop;
 
    std::function<void(std::function<void()> call, const std::shared_ptr<Ice::Connection>& con)> dispatcher;
 
    std::function<std::string(int id)> compactIdResolver;
 
    std::function<void(const Ice::BatchRequest& req, int count, int size)> batchRequestInterceptor;
 
#if defined(__clang__)
#   pragma clang diagnostic pop
#endif
 
#else
 
    ThreadNotificationPtr threadHook;
 
    DispatcherPtr dispatcher;
 
    CompactIdResolverPtr compactIdResolver;
 
    BatchRequestInterceptorPtr batchRequestInterceptor;
#endif
 
    ValueFactoryManagerPtr valueFactoryManager;
};
 
ICE_API CommunicatorPtr initialize(int& argc, const char* argv[],
                                   const InitializationData& initData = InitializationData(),
                                   int version = ICE_INT_VERSION);
 
inline CommunicatorPtr initialize(int& argc, char* argv[], const InitializationData& initData = InitializationData(),
                                   int version = ICE_INT_VERSION)
{
    return initialize(argc, const_cast<const char**>(argv), initData, version);
}
 
ICE_API CommunicatorPtr initialize(int& argc, const char* argv[], ICE_CONFIG_FILE_STRING configFile,
                                   int version = ICE_INT_VERSION);
 
inline CommunicatorPtr initialize(int& argc, char* argv[], ICE_CONFIG_FILE_STRING configFile,
                                  int version = ICE_INT_VERSION)
{
    return initialize(argc, const_cast<const char**>(argv), configFile, version);
}
 
#ifdef _WIN32
 
ICE_API CommunicatorPtr initialize(int& argc, const wchar_t* argv[],
                                   const InitializationData& initData = InitializationData(),
                                   int version = ICE_INT_VERSION);
 
inline CommunicatorPtr initialize(int& argc, wchar_t* argv[], const InitializationData& initData = InitializationData(),
                                   int version = ICE_INT_VERSION)
{
    return initialize(argc, const_cast<const wchar_t**>(argv), initData, version);
}
 
ICE_API CommunicatorPtr initialize(int& argc, const wchar_t* argv[], ICE_CONFIG_FILE_STRING configFile,
                                   int version = ICE_INT_VERSION);
 
inline CommunicatorPtr initialize(int& argc, wchar_t* argv[], ICE_CONFIG_FILE_STRING configFile,
                                  int version = ICE_INT_VERSION)
{
    return initialize(argc, const_cast<const wchar_t**>(argv), configFile, version);
}
#endif
 
ICE_API CommunicatorPtr initialize(StringSeq& seq, const InitializationData& initData = InitializationData(),
                                   int version = ICE_INT_VERSION);
 
ICE_API CommunicatorPtr initialize(StringSeq& seq, ICE_CONFIG_FILE_STRING configFile, int version = ICE_INT_VERSION);
 
ICE_API CommunicatorPtr initialize(const InitializationData& initData = InitializationData(),
                                   int version = ICE_INT_VERSION);
 
ICE_API CommunicatorPtr initialize(ICE_CONFIG_FILE_STRING configFile, int version = ICE_INT_VERSION);
 
ICE_API LoggerPtr getProcessLogger();
 
ICE_API void setProcessLogger(const LoggerPtr& logger);
 
typedef Ice::Plugin* (*PluginFactory)(const ::Ice::CommunicatorPtr& communicator, const std::string& name,
                                      const ::Ice::StringSeq& args);
 
ICE_API void registerPluginFactory(const std::string& name, PluginFactory factory, bool loadOnInit);
 
class ICE_API CommunicatorHolder
{
public:
 
    CommunicatorHolder();
 
#ifdef ICE_CPP11_MAPPING
 
    template<class... T>
    explicit CommunicatorHolder(T&&... args) :
        _communicator(std::move(initialize(std::forward<T>(args)...)))
    {
    }
 
    CommunicatorHolder(std::shared_ptr<Communicator> communicator);
 
    CommunicatorHolder& operator=(std::shared_ptr<Communicator> communicator);
 
    CommunicatorHolder(const CommunicatorHolder&) = delete;
    CommunicatorHolder(CommunicatorHolder&&) = default;
 
    CommunicatorHolder& operator=(CommunicatorHolder&& holder) noexcept;
 
    explicit operator bool() const;
 
#else // C++98 mapping
 
    CommunicatorHolder(int& argc, const char* argv[], const InitializationData& initData = InitializationData(),
                       int version = ICE_INT_VERSION);
 
    CommunicatorHolder(int& argc, char* argv[], const InitializationData& initData = InitializationData(),
                       int version = ICE_INT_VERSION);
 
    CommunicatorHolder(int& argc, const char* argv[], const char* configFile, int version = ICE_INT_VERSION);
 
    CommunicatorHolder(int& argc, char* argv[], const char* configFile, int version = ICE_INT_VERSION);
 
#   ifdef _WIN32
 
    CommunicatorHolder(int& argc, const wchar_t* argv[], const InitializationData& initData = InitializationData(),
                       int version = ICE_INT_VERSION);
 
    CommunicatorHolder(int& argc, wchar_t* argv[], const InitializationData& initData = InitializationData(),
                       int version = ICE_INT_VERSION);
 
    CommunicatorHolder(int& argc, const wchar_t* argv[], const char* configFile, int version = ICE_INT_VERSION);
 
    CommunicatorHolder(int& argc, wchar_t* argv[], const char* configFile, int version = ICE_INT_VERSION);
#   endif
 
    explicit CommunicatorHolder(StringSeq& seq, const InitializationData& initData = InitializationData(),
                                int version = ICE_INT_VERSION);
 
    CommunicatorHolder(StringSeq& seq, const char* configFile, int version = ICE_INT_VERSION);
 
    explicit CommunicatorHolder(const InitializationData& initData, int version = ICE_INT_VERSION);
 
    explicit CommunicatorHolder(const char* configFile, int version = ICE_INT_VERSION);
 
    CommunicatorHolder(const CommunicatorPtr& communicator);
 
    CommunicatorHolder& operator=(const CommunicatorPtr& communicator);
 
    operator bool() const;
 
    //
    // Required for successful copy-initialization, but not
    // defined as it should always be elided by the compiler.
    CommunicatorHolder(const CommunicatorHolder&);
 
#endif
 
    ~CommunicatorHolder();
 
    const CommunicatorPtr& communicator() const;
 
    const CommunicatorPtr& operator->() const;
 
    CommunicatorPtr release();
 
private:
 
    CommunicatorPtr  _communicator;
};
 
ICE_API Identity stringToIdentity(const std::string& str);
 
ICE_API std::string identityToString(const Identity& id, ToStringMode mode = ICE_ENUM(ToStringMode, Unicode));
 
}
 
namespace IceInternal
{
 
//
// Some Ice extensions need access to the Ice internal instance. Do
// not use this operation for regular application code! It is intended
// to be used by modules such as Freeze.
//
ICE_API InstancePtr getInstance(const ::Ice::CommunicatorPtr&);
ICE_API IceUtil::TimerPtr getInstanceTimer(const ::Ice::CommunicatorPtr&);
 
}
 
#endif