Application.h

Go to the documentation of this file.

//
// Copyright (c) ZeroC, Inc. All rights reserved.
//
 
#ifndef ICE_APPLICATION_H
#define ICE_APPLICATION_H
 
#include <Ice/Initialize.h>
#include <IceUtil/Mutex.h>
#include <IceUtil/Cond.h>
#include <IceUtil/CtrlCHandler.h>
 
namespace Ice
{
 
using IceUtil::CtrlCHandler;
using IceUtil::CtrlCHandlerCallback;
 
#ifdef ICE_CPP11_MAPPING
 
enum class SignalPolicy : unsigned char
#else
enum SignalPolicy
#endif
{
    HandleSignals,
    NoSignalHandling
};
 
class ICE_API Application
{
public:
 
    Application(SignalPolicy policy = ICE_ENUM(SignalPolicy, HandleSignals));
 
#ifdef ICE_CPP11_MAPPING
    Application(const Application&) = delete;
    Application& operator=(const Application&) = delete;
#endif
 
    virtual ~Application();
 
    int main(int argc, const char* const argv[], const InitializationData& initData = InitializationData(),
             int version = ICE_INT_VERSION);
 
    int main(int argc, const char* const argv[], ICE_CONFIG_FILE_STRING configFile, int version = ICE_INT_VERSION);
 
#ifdef _WIN32
 
    int main(int argc, const wchar_t* const argv[], const InitializationData& initData = InitializationData(),
             int version = ICE_INT_VERSION);
 
    int main(int argc, const wchar_t* const argv[], ICE_CONFIG_FILE_STRING configFile, int version = ICE_INT_VERSION);
#endif
 
    int main(const StringSeq& args, const InitializationData& initData = InitializationData(),
             int version = ICE_INT_VERSION);
 
    int main(const StringSeq& args, ICE_CONFIG_FILE_STRING configFile, int version = ICE_INT_VERSION);
 
    virtual int run(int argc, char* argv[]) = 0;
 
    virtual void interruptCallback(int signal);
 
    static const char* appName();
 
    static CommunicatorPtr communicator();
 
    static void destroyOnInterrupt();
 
    static void shutdownOnInterrupt();
 
    static void ignoreInterrupt();
 
    static void callbackOnInterrupt();
 
    static void holdInterrupt();
 
    static void releaseInterrupt();
 
    static bool interrupted();
 
protected:
 
    virtual int doMain(int, char*[], const InitializationData&, Int);
 
    static IceUtil::Mutex _mutex;
 
    static IceUtil::Cond _condVar;
 
    static bool _callbackInProgress;
 
    static bool _destroyed;
 
    static bool _interrupted;
 
    static std::string _appName;
 
    static CommunicatorPtr _communicator;
 
    static SignalPolicy _signalPolicy;
 
    static Application* _application;
 
private:
 
    static void holdInterruptCallback(int);
    static void destroyOnInterruptCallback(int);
    static void shutdownOnInterruptCallback(int);
    static void callbackOnInterruptCallback(int);
 
#ifndef ICE_CPP11_MAPPING
    //
    // Not defined, make Application non-copyable
    //
    Application(const Application&);
    Application& operator=(const Application&);
#endif
 
};
 
}
 
#endif