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