// Application的入口函数，提供了丰富的初始化方式，一般使用第一个
// 将应用主函数参数直接传入即可
int main(int, char*[]);
int main(int, char*[], const char*);
int main(int, char*[], const Ice::InitializationData&);
int main(int, char*[], const char*, const Ice::LoggerPtr&);
int main(const StringSeq&);
int main(const StringSeq&, const char*);
int main(const StringSeq&, const Ice::InitializationData&);

// 应用的执行循环，应用需要继承这个函数并用自己的逻辑重写
virtual int run(int, char*[]) = 0;

// 信号回调函数
// 如果需要自己对信号进行处理，则需要继承和改写这个函数
// 注意，需在run()函数中调用callbackOnInterrupt()来向Ice表示使用用户回调
// 该函数的默认实现是空函数
virtual void interruptCallback(int);
 
// 返回应用名，即argv[0]
static const char* appName();

// 返回当前使用的Ice通信器实例指针
static CommunicatorPtr communicator();

// 设置信号处理模式
//
// 销毁模式：信号到来时将通信器实例销毁，也是Application的默认模式
static void destroyOnInterrupt();

// 关闭模式：信号到来时将通信器实例关闭，但不销毁
static void shutdownOnInterrupt();

// 忽略模式：信号到来时将通信器不做任何处理
static void ignoreInterrupt();

// 用户模式：信号到来时将调用interruptCallback()函数
static void callbackOnInterrupt();

// 信号的阻止和放开，不常用
// 阻塞信号的到来
static void holdInterrupt();

// 放开被阻塞的信号
static void releaseInterrupt();

// Application当前是否被信号中断
// 可用于判断Application的结束是否由于信号造成
static bool interrupted();

#include <Ice/Ice.h>
int main(int argc, char * argv[])
{
       int status = 0;
       Ice::CommunicatorPtr ic;
       try {
              ic = Ice::initialize(argc, argv);

// Server code here...

// ...

} catch (const Ice::Exception & e) {
              cerr << e << endl;
              status = 1;
       }

if (ic)
              ic->destroy();
       return status;
}

#include <Ice/Ice.h>
class MyApplication : virtual public Ice::Application
{
public:
       virtual int run(int, char * []) {

       // 如果需要，设置信号回调模式
              interruptCallback();
              // ignoreInterrupt();

              // Add Server code here...
              // ...

              return 0;
       }
     
      virtual void interruptCallback(int) {
             cout << appName() << “ receive signal ” << endl;
      }
};

int main(int argc, char * argv[])
{

       MyApplication app;
       return app.main(argc, argv);
}

int
Ice::Application::main(int argc, char* argv[], const InitializationData& initData)
{
    // 不允许重复调用
    if(_communicator != 0)
    {
        cerr << argv[0] << ": only one instance of the Application class can be used" << endl;
        return EXIT_FAILURE;
    }
    int status;

try
    {
        // 设置信号捕捉器
         CtrlCHandler ctrCHandler;
        _ctrlCHandler = &ctrCHandler;

try
        {   // 内部使用的条件变量初始化，主要用于信号阻塞
            if(_condVar.get() == 0)
            {
                _condVar.reset(new Cond);
            }

// 初始化Ice通信器及其它变量（均为静态变量）
            _interrupted = false;
            _appName = argv[0];    // 设置应用名
                
            _application = this;
            _communicator = initialize(argc, argv, initData);
            _destroyed = false;

// 判断应用是否提供了Ice.Nohup参数
            // 如果Ice.Nohup大于0, Application会忽略SIGHUP(UNIX) 和 
           // CTRL_LOGOFF_EVENT (Windows). 因此，如果启动应用的用户注销，
           // 设置了Ice.Nohup 的应用能继续运行(只适用于C++)。
             _nohup = (_communicator->getProperties()->getPropertyAsInt("Ice.Nohup") > 0);
        
            // 收到信号的默认处理方式是销毁通信器
            destroyOnInterrupt();
            status = run(argc, argv);
        }
        catch(const IceUtil::Exception& ex)
        {
            cerr << _appName << ": " << ex << endl;
            status = EXIT_FAILURE;
        }
        catch(const std::exception& ex)
        {
            cerr << _appName << ": std::exception: " << ex.what() << endl;
            status = EXIT_FAILURE;
        }
        catch(const std::string& msg)
        {
            cerr << _appName << ": " << msg << endl;
            status = EXIT_FAILURE;
        }
        catch(const char* msg)
        {
            cerr << _appName << ": " << msg << endl;
            status = EXIT_FAILURE;
        }
        catch(...)
        {
            cerr << _appName << ": unknown exception" << endl;
            status = EXIT_FAILURE;
        }

// Application清理时，需要忽略所有信号
       ignoreInterrupt();
        {
            StaticMutex::Lock lock(_mutex);
            while(_callbackInProgress)
            {
                _condVar->wait(lock);
            }
            if(_destroyed)
            {
                _communicator = 0;
            }
            else
            {
                _destroyed = true;
                //
                // And _communicator != 0, meaning will be destroyed
                // next, _destroyed = true also ensures that any
                // remaining callback won't do anything
                //
            }
            _application = 0;
        }

// 清理通信器(如果没有通过信号清理过)
        if(_communicator != 0)
        {  
            try
            {
                _communicator->destroy();
            }
            catch(const IceUtil::Exception& ex)
            {
                cerr << _appName << ": " << ex << endl;
                status = EXIT_FAILURE;
            }
            catch(const std::exception& ex)
            {
                cerr << _appName << ": std::exception: " << ex.what() << endl;
                status = EXIT_FAILURE;
            }
            catch(...)
            {
                cerr << _appName << ": unknown exception" << endl;
                status = EXIT_FAILURE;
            }
            _communicator = 0;
        }

//
        // Set _ctrlCHandler to 0 only once communicator->destroy() has completed.
        // 
        _ctrlCHandler = 0;
    }
    catch(const CtrlCHandlerException&)
    {
        cerr << argv[0] << ": only one instance of the Application class can be used" << endl;
        status = EXIT_FAILURE;
    }
   
    return status;
}