module Demo
{interface Printer{void printString(string s);}
}

#include <Ice/Ice.h>
#include <>usingnamespace std;
usingnamespace Demo;class PrinterI : public Printer
{
public:virtualvoid printString(string s, const Ice::Current&) override;
};void
PrinterI::printString(string s, const Ice::Current&)
{cout << s << endl;
}int
main(int argc, char* argv[])
{try{Ice::CommunicatorHolder ich(argc, argv);auto adapter = ich->createObjectAdapterWithEndpoints("SimplePrinterAdapter", "default -h localhost -p 10000");auto servant = make_shared<PrinterI>();adapter->add(servant, Ice::stringToIdentity("SimplePrinter"));adapter->activate();ich->waitForShutdown();}catch(const std::exception& e){cerr << () << endl;return1;}return0;
}

#include <Ice/Ice.h>
#include <>
#include <stdexcept>usingnamespace std;
usingnamespace Demo;int
main(int argc, char* argv[])
{try{Ice::CommunicatorHolder ich(argc, argv);auto base = ich->stringToProxy("SimplePrinter:default -p 10000");auto printer = Ice::checkedCast<PrinterPrx>(base);if(!printer){throw std::runtime_error("Invalid proxy");}printer->printString("Hello World!");}catch(const std::exception& e){cerr << () << endl;return1;}return0;
}

module Demo
{interface ServerService{void requireService(string ident, string s);}interface ClientCallback{void callback(string s);}
}

#include <QEvent>
#include <QObject>
#include <QCoreApplication>#include <stdexcept>#include <Ice/Ice.h>
#include ""usingnamespace std;class CustomEvent : public QEvent
{
public:explicit CustomEvent(Type type) :QEvent(type) {}enum PMAlgoEventType {CustomEvent_RequireService = 0x00000001,};string m_params;Demo::ClientCallbackPrxPtr m_callback;
};class ServerI : public Demo::ServerService
{
public:ServerI(){}/* Use event loop implement in QObject by Qt to post client requirements to user thread.* May be replaced by event loop in pure C++, handler in java and so on.*/void setImplement(QObject *implement) {m_implement = implement;}void requireService(string ident, string s, const ::Ice::Current& current) override{/* we donot generate the client requirement here, but post it to main thread as this function is called in ice server threads.* When the interface is not thread safe or time-consuming, or has thread associated context like python interpreter, we must post* it to a constant thread managered by ourself to avoid running exceptions.* ident : client object identification, used to build bidirectional connection to cross firewall and local network* s : params used for servcie*/CustomEvent *e = new CustomEvent(QEvent::Type(QEvent::User + CustomEvent::CustomEvent_RequireService));e->m_params   = s;e->m_callback = Ice::uncheckedCast<Demo::ClientCallbackPrx>(current.con->createProxy(Ice::stringToIdentity(ident)));QCoreApplication::postEvent(m_implement, e);}private:QObject *m_implement;
};class IceManager
{
public:IceManager() {/* set up global ice configurations, here we just set thread pool to 2 to avoid deadlock on ice callback,* other settings are configurable as the same.*/Ice::PropertiesPtr props0 = Ice::createProperties();props0->setProperty("", "2");props0->setProperty("Max", "2");props0->setProperty("", "2");props0->setProperty("Max", "2");props0->setProperty("", "1");Ice::InitializationData id;id.properties = props0;m_ich = Ice::CommunicatorHolder(id);}bool setImplement(QObject *implement) {try {/* create server object and add it to ice adapter to receive client requirements.* The adapter identification is used for ice pack service, we donot use it now.* The endpoints is the location url where client can access to require service.* The servant identification is used to identify servant as we can add multiple servants to one adapter.*/shared_ptr<ServerI> servant = make_shared<ServerI>();servant->setImplement(implement);auto adapter = m_ich->createObjectAdapterWithEndpoints("ServerAdapter", "default -h localhost -p 10000");adapter->add(servant, Ice::stringToIdentity("Server"));adapter->activate();} catch (const exception &e){cout << "Failed to create ice server object, error-->%s" << () << endl;returnfalse;}returntrue;}private:Ice::CommunicatorHolder m_ich;
};class MainWorker : public QObject
{
public:MainWorker(QObject *parent = nullptr) : QObject(parent) {}protected:/* Receive client requirements and deliver to associated servcie function */void customEvent(QEvent *e) {CustomEvent *event = (CustomEvent *)e;int type = event->type() - QEvent::User;if (CustomEvent::CustomEvent_RequireService == type) {renderService(event->m_params, event->m_callback);} else {cout << "Unrecognized event type-->" << type << "!" << endl;}}private:/* a simple implement */void renderService(conststring& s, const Demo::ClientCallbackPrxPtr& callback) {cout << s << endl;callback->callback("Requirement done!");}
};int main(int argc, char *argv[])
{QCoreApplication a(argc, argv);MainWorker worker(&a);IceManager ice_manager;(&worker);return a.exec();
}

#ifndef HELPER_H
#define HELPER_H#include <QTimer>
#include <QEvent>
#include <QObject>
#include <QThread>
#include <QCoreApplication>#include <stdexcept>#include <Ice/Ice.h>
#include ""usingnamespace std;/* custom event used for event loop */class CustomEvent : public QEvent
{
public:explicit CustomEvent(Type type) :QEvent(type) {}enum PMAlgoEventType {CustomEvent_RequireCallback = 0x00000001,};string m_params;
};class ClientI : public Demo::ClientCallback
{
public:ClientI(){}/* Use event loop implement in QObject by Qt to post client requirements to user thread.* May be replaced by event loop in pure C++, handler in java and so on.*/void setImplement(QObject *implement) {m_server_implement = implement;}void callback(string s, const ::Ice::Current&) override{/* we donot generate the client requirement here, but post it to main thread as this function is called in ice server threads.* When the interface is not thread safe or time-consuming, or has thread associated context like python interpreter, we must post* it to a constant thread managered by ourself to avoid running exceptions.* s : params used for servcie*/CustomEvent *e = new CustomEvent(QEvent::Type(QEvent::User + CustomEvent::CustomEvent_RequireCallback));e->m_params    = s;QCoreApplication::postEvent(m_server_implement, e);}private:QObject *m_server_implement;
};class ServerRequirer : public QObject
{Q_OBJECT
public:explicit ServerRequirer(const Ice::CommunicatorHolder &ich, const Ice::ObjectAdapterPtr &adapter, conststring& ident) {m_ic        = ();m_adapter   = adapter;m_ident     = ident;}public slots:void slot_requireServcie(conststring& s) {if (nullptr == m_server_prx.get()) {/* connection is not established, try to establish connection first */try {auto base = m_ic->stringToProxy("Server:default -h localhost -p 10000");m_server_prx = Ice::checkedCast<Demo::ServerServicePrx>(base);if(nullptr != m_server_prx.get()){/* set up eseential configurations on Ice connection to keep this connection alive */m_server_prx->ice_getConnection()->setACM(Ice::nullopt, Ice::ACMClose::CloseOff, Ice::ACMHeartbeat::HeartbeatAlways);m_server_prx->ice_getConnection()->setAdapter(m_adapter);}}catch(const exception& e){cerr << () << endl;}}if (nullptr != m_server_prx.get()) {try {/* require remote object call via object proxy */m_server_prx->requireService(m_ident, s);}catch(const exception& e){/* connection lost, reset it and re-establish it on next call */cerr << () << endl;();}}}private:string m_ident;Ice::CommunicatorPtr      m_ic;Ice::ObjectAdapterPtr     m_adapter;Demo::ServerServicePrxPtr m_server_prx;
};class IceManager : public QThread
{Q_OBJECT
public:/* Craete ice global communicator and manager ice requirement.* Server requirements are posted in seperate thread as they may be time-consuming* Local object that implements callback is identified through bidirectional connection instead of* creating a new connection fron server to client, as client may be defensed behind firewall or local network.*/IceManager() {/* register qt meta type */qRegisterMetaType<string>("string");/* set up global ice configurations, here we just set thread pool to 2 to avoid deadlock on ice callback,* other settings are configurable as the same.*/Ice::PropertiesPtr props0 = Ice::createProperties();props0->setProperty("", "2");props0->setProperty("Max", "2");props0->setProperty("", "2");props0->setProperty("Max", "2");props0->setProperty("", "1");/* create global ice communicator */Ice::InitializationData id;id.properties = props0;m_ich = Ice::CommunicatorHolder(id);}bool start(QObject *implement) {try {/* create client object and add it to ice adapter to receive server callbacks.* The adapter is created without identification as we donot access it by endpoints.* Instead, we pass it through the connection established with server to build a bidirectional connection.*/m_ident = "Client";shared_ptr<ClientI> servant = make_shared<ClientI>();servant->setImplement(implement);m_adapter = m_ich->createObjectAdapter("");m_adapter->add(servant, Ice::stringToIdentity(m_ident));m_adapter->activate();} catch (const exception &e) {cout << "Failed to create ice object, error-->%s" << () << endl;returnfalse;}/* create ice service requirer in seperate thread, as network request may be time-consuming */m_requirer = new ServerRequirer(m_ich, m_adapter, m_ident);m_requirer->moveToThread(this);connect(this, SIGNAL(signal_requireService(string)), m_requirer, SLOT(slot_requireServcie(string)));QThread::start();returntrue;}public slots:void slot_requireService() {string s("Hello world!");emit signal_requireService(s);}signals:void signal_requireService(string s);private:Ice::CommunicatorHolder m_ich;Ice::ObjectAdapterPtr   m_adapter;string          m_ident;        /* local object identification */ServerRequirer *m_requirer;
};class MainWorker : public QObject
{
public:MainWorker(QObject *parent = nullptr) : QObject(parent) {}protected:/* Receive callbacks from server and deliver to associated callback function */void customEvent(QEvent *e) {CustomEvent *event = (CustomEvent *)e;int type = event->type() - QEvent::User;if (CustomEvent::CustomEvent_RequireCallback == type) {renderCallback(event->m_params);} else {cout << "Unrecognized event type-->" << type << "!" << endl;}}private:/* a simple implement */void renderCallback(conststring& s) {cout << s << endl;}
};#endif// HELPER_H

#include ""int main(int argc, char *argv[])
{QCoreApplication a(argc, argv);/* local worker */MainWorker worker(&a);/* ice service manager */IceManager ice_manager;(&worker);/* require serve service every 3 seconds */QTimer timer;QObject::connect(&timer, SIGNAL(timeout()), &ice_manager, SLOT(slot_requireService()));(3 * 1000);return a.exec();
}