zeroc-ice 3.7.11 → 3.8.1

data/dist/ice/cpp/include/Ice/Application.h

@@ -1,326 +0,0 @@
-//
-// 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
-/**
- * Determines how the Application class handles signals.
- */
-enum class SignalPolicy : unsigned char
-#else
-enum SignalPolicy
-#endif
-{
-    /** Enables signal handling. */
-    HandleSignals,
-    /** Disables signal handling, meaning signals retain their default behavior. */
-    NoSignalHandling
-};
-
-/**
- * Singleton helper class that simplifies Ice initialization, finalization and signal handling.
- * An application uses this class by writing a subclass and implementing the run method.
- * \headerfile Ice/Ice.h
- */
-class ICE_API Application
-{
-public:
-
-    /**
-     * The constructor configures the signal handling behavior.
-     * @param policy Specifies whether to handle signals. If not specified, the default behavior
-     * is to handle signals.
-     */
-    Application(SignalPolicy policy = ICE_ENUM(SignalPolicy, HandleSignals));
-
-#ifdef ICE_CPP11_MAPPING
-    /// \cond IGNORE
-    Application(const Application&) = delete;
-    Application& operator=(const Application&) = delete;
-    /// \endcond
-#endif
-
-    virtual ~Application();
-
-    /**
-     * Call this main() from the global main(). main()
-     * initializes the Communicator, calls run() and destroys the
-     * the Communicator upon return from run(). It handles all
-     * exceptions properly, i.e., error message are printed if
-     * exceptions propagate to main(), and the Communicator is always
-     * destroyed, regardless of exceptions.
-     * @param argc Specifies the number of arguments in argv.
-     * @param argv The command-line arguments.
-     * @param initData Configuration data for the new Communicator.
-     * @param version Indicates the Ice version with which the application is compatible. If not
-     * specified, the version of the Ice installation is used.
-     * @return The application's exit status.
-     */
-    int main(int argc, const char* const argv[], const InitializationData& initData = InitializationData(),
-             int version = ICE_INT_VERSION);
-
-    /**
-     * Call this main() from the global main(). main()
-     * initializes the Communicator, calls run() and destroys the
-     * the Communicator upon return from run(). It handles all
-     * exceptions properly, i.e., error message are printed if
-     * exceptions propagate to main(), and the Communicator is always
-     * destroyed, regardless of exceptions.
-     * @param argc Specifies the number of arguments in argv.
-     * @param argv The command-line arguments.
-     * @param configFile The name of an Ice configuration file.
-     * @param version Indicates the Ice version with which the application is compatible. If not
-     * specified, the version of the Ice installation is used.
-     * @return The application's exit status.
-     */
-    int main(int argc, const char* const argv[], ICE_CONFIG_FILE_STRING configFile, int version = ICE_INT_VERSION);
-
-#ifdef _WIN32
-    /**
-     * Call this main() from the global main(). main()
-     * initializes the Communicator, calls run() and destroys the
-     * the Communicator upon return from run(). It handles all
-     * exceptions properly, i.e., error message are printed if
-     * exceptions propagate to main(), and the Communicator is always
-     * destroyed, regardless of exceptions.
-     * @param argc Specifies the number of arguments in argv.
-     * @param argv The command-line arguments.
-     * @param initData Configuration data for the new Communicator.
-     * @param version Indicates the Ice version with which the application is compatible. If not
-     * specified, the version of the Ice installation is used.
-     * @return The application's exit status.
-     */
-    int main(int argc, const wchar_t* const argv[], const InitializationData& initData = InitializationData(),
-             int version = ICE_INT_VERSION);
-
-    /**
-     * Call this main() from the global main(). main()
-     * initializes the Communicator, calls run() and destroys the
-     * the Communicator upon return from run(). It handles all
-     * exceptions properly, i.e., error message are printed if
-     * exceptions propagate to main(), and the Communicator is always
-     * destroyed, regardless of exceptions.
-     * @param argc Specifies the number of arguments in argv.
-     * @param argv The command-line arguments.
-     * @param configFile The name of an Ice configuration file.
-     * @param version Indicates the Ice version with which the application is compatible. If not
-     * specified, the version of the Ice installation is used.
-     * @return The application's exit status.
-     */
-    int main(int argc, const wchar_t* const argv[], ICE_CONFIG_FILE_STRING configFile, int version = ICE_INT_VERSION);
-#endif
-
-    /**
-     * Call this main() from the global main(). main()
-     * initializes the Communicator, calls run() and destroys the
-     * the Communicator upon return from run(). It handles all
-     * exceptions properly, i.e., error message are printed if
-     * exceptions propagate to main(), and the Communicator is always
-     * destroyed, regardless of exceptions.
-     * @param args The command-line arguments.
-     * @param initData Configuration data for the new Communicator.
-     * @param version Indicates the Ice version with which the application is compatible. If not
-     * specified, the version of the Ice installation is used.
-     * @return The application's exit status.
-     */
-    int main(const StringSeq& args, const InitializationData& initData = InitializationData(),
-             int version = ICE_INT_VERSION);
-
-    /**
-     * Call this main() from the global main(). main()
-     * initializes the Communicator, calls run() and destroys the
-     * the Communicator upon return from run(). It handles all
-     * exceptions properly, i.e., error message are printed if
-     * exceptions propagate to main(), and the Communicator is always
-     * destroyed, regardless of exceptions.
-     * @param args The command-line arguments.
-     * @param configFile The name of an Ice configuration file.
-     * @param version Indicates the Ice version with which the application is compatible. If not
-     * specified, the version of the Ice installation is used.
-     * @return The application's exit status.
-     */
-    int main(const StringSeq& args, ICE_CONFIG_FILE_STRING configFile, int version = ICE_INT_VERSION);
-
-    /**
-     * run is given a copy of the remaining argc/argv arguments,
-     * after the communicator initialization in the caller (main)
-     * has removed all Ice-related arguments.
-     * @param argc Specifies the number of arguments in argv.
-     * @param argv The command-line arguments.
-     * @return The application's exit status.
-     */
-    virtual int run(int argc, char* argv[]) = 0;
-
-    /**
-     * Override this method to provide a custom application interrupt
-     * hook. You must call callbackOnInterrupt for this method to
-     * be called. Note that the interruptCallback can be called
-     * concurrently with any other thread (including main) in your
-     * application and thus must take appropriate concurrency
-     * precautions.
-     * @param signal The signal identifier.
-     */
-    virtual void interruptCallback(int signal);
-
-    /**
-     * Obtains the application name, i.e., argv[0].
-     * @return The application's name.
-     */
-    static const char* appName();
-
-    /**
-     * Obtains the application's Communicator instance.
-     * One limitation of this class is that there can only be one
-     * Application instance, with one global Communicator, accessible
-     * with this communicator() operation. This limitation is due to
-     * how the signal handling functions below operate. If you require
-     * multiple Communicators, then you cannot use this Application
-     * framework class.
-     * @return The application's communicator.
-     */
-    static CommunicatorPtr communicator();
-
-    /**
-     * Configures the application to destroy the communicator when one of the
-     * monitored signals is raised. This is the default behavior.
-     */
-    static void destroyOnInterrupt();
-
-    /**
-     * Configures the application to shut down the communicator when one of the
-     * monitored signals is raised.
-     */
-    static void shutdownOnInterrupt();
-
-    /**
-     * Configures the application to ignore signals.
-     */
-    static void ignoreInterrupt();
-
-    /**
-     * Configures the application to invoke interruptCallback when a signal occurs,
-     * thereby giving the subclass responsibility for handling the signal.
-     */
-    static void callbackOnInterrupt();
-
-    /**
-     * Configures the application to ignore (but remember) a signal.
-     * A stored signal (if any) can be handled later by calling releaseInterrupt.
-     */
-    static void holdInterrupt();
-
-    /**
-     * Processes a stored signal (if any) using the current signal handling configuration.
-     */
-    static void releaseInterrupt();
-
-    /**
-     * Indicates whether a signal handler was triggered.
-     * This can be used once Communicator::waitForShutdown() returns to
-     * test whether the shutdown was due to an interrupt (returns true)
-     * or because Communicator::shutdown() was called (returns false).
-     * @return True if a signal handler was triggered, false otherwise.
-     */
-    static bool interrupted();
-
-protected:
-
-    /**
-     * Helper function that implements the application logic.
-     */
-    virtual int doMain(int, char*[], const InitializationData&, Int);
-
-    /**
-     * Used to synchronize the main thread and the CtrlCHandler thread.
-     */
-    static IceUtil::Mutex _mutex;
-
-    /**
-     * Used to synchronize the main thread and the CtrlCHandler thread.
-     */
-    static IceUtil::Cond _condVar;
-
-    /**
-     * True if a signal handling callback is currently executing.
-     * Can change while run() and communicator->destroy() are running!
-     */
-    static bool _callbackInProgress;
-
-    /**
-     * True if the communicator has been destroyed.
-     * Can change while run() and communicator->destroy() are running!
-     */
-    static bool _destroyed;
-
-    /**
-     * True if an interrupt signal was received.
-     * Can change while run() and communicator->destroy() are running!
-     */
-    static bool _interrupted;
-
-    /**
-     * The application's name.
-     * Immutable during run() and until communicator->destroy() has returned.
-     * Before and after run(), and once communicator->destroy() has returned,
-     * we assume that only the main thread and CtrlCHandler threads are running.
-     */
-    static std::string _appName;
-
-    /**
-     * The application's communicator.
-     * Immutable during run() and until communicator->destroy() has returned.
-     * Before and after run(), and once communicator->destroy() has returned,
-     * we assume that only the main thread and CtrlCHandler threads are running.
-     */
-    static CommunicatorPtr _communicator;
-
-    /**
-     * The signal-handling policy specified at construction.
-     * Immutable during run() and until communicator->destroy() has returned.
-     * Before and after run(), and once communicator->destroy() has returned,
-     * we assume that only the main thread and CtrlCHandler threads are running.
-     */
-    static SignalPolicy _signalPolicy;
-
-    /**
-     * The singleton instance.
-     * Immutable during run() and until communicator->destroy() has returned.
-     * Before and after run(), and once communicator->destroy() has returned,
-     * we assume that only the main thread and CtrlCHandler threads are running.
-     */
-    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

data/dist/ice/cpp/include/Ice/AsyncResult.h

@@ -1,155 +0,0 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
-
-#ifndef ICE_ASYNC_RESULT_H
-#define ICE_ASYNC_RESULT_H
-
-#ifndef ICE_CPP11_MAPPING
-
-#include <IceUtil/Monitor.h>
-#include <IceUtil/Mutex.h>
-#include <Ice/LocalObject.h>
-#include <Ice/CommunicatorF.h>
-#include <Ice/ConnectionF.h>
-#include <Ice/ProxyF.h>
-#include <Ice/AsyncResultF.h>
-
-namespace Ice
-{
-
-/**
- * Represents the result of an asynchronous invocation using the C++98 mapping.
- * \headerfile Ice/Ice.h
- */
-class ICE_API AsyncResult : private IceUtil::noncopyable, public Ice::LocalObject
-{
-public:
-
-    virtual ~AsyncResult();
-
-    /**
-     * Prevents a queued invocation from being sent or, if the invocation has already been sent,
-     * ignores a reply if the server sends one. cancel is a local operation and has no effect
-     * on the server. A canceled invocation is considered to be completed, meaning isCompleted
-     * returns true, and the result of the invocation is an InvocationCanceledException.
-     */
-    virtual void cancel() = 0;
-
-    /**
-     * Allows you to create ordered or hashed collections of pending asynchronous invocations.
-     * @return A unique hash code for this object.
-     */
-    virtual Int getHash() const = 0;
-
-    /**
-     * Obtains the communicator that sent the invocation.
-     * @return A reference to the communicator.
-     */
-    virtual CommunicatorPtr getCommunicator() const = 0;
-
-    /**
-     * Obtains the connection that was used for the invocation. Note that, for typical asynchronous
-     * proxy invocations, this method returns a nil value because the possibility of automatic retries
-     * means the connection that is currently in use could change unexpectedly. The getConnection
-     * method only returns a non-nil value when the AsyncResult object is obtained by calling
-     * Connection::begin_flushBatchRequests.
-     * @return A reference to the connection.
-     */
-    virtual ConnectionPtr getConnection() const = 0;
-
-    /**
-     * Obtains the proxy that was used to call the begin_ method, or nil if the AsyncResult object was
-     * not obtained via an asynchronous proxy invocation.
-     * @return A reference to the proxy.
-     */
-    virtual ObjectPrxPtr getProxy() const = 0;
-
-    /**
-     * Obtains the completion status of the invocation.
-     * @return True if, at the time it is called, the result of an invocation is available, indicating
-     * that a call to the end_ method will not block the caller. Otherwise, if the result is not yet
-     * available, the method returns false.
-     */
-    virtual bool isCompleted() const = 0;
-
-    /**
-     * Blocks the caller until the result of an invocation becomes available.
-     */
-    virtual void waitForCompleted() = 0;
-
-    /**
-     * Obtains the sent status of the invocation.
-     * @return True if, at the time it is called, the request has been written to the local transport
-     * (whether it was initially queued or not). Otherwise, if the request is still queued or an
-     * exception occurred before the request could be sent, this method returns false.
-     */
-    virtual bool isSent() const = 0;
-
-    /**
-     * Blocks the calling thread until a request has been written to the client-side transport,
-     * or an exception occurs.
-     */
-    virtual void waitForSent() = 0;
-
-    /**
-     * Throws the local exception that caused the invocation to fail. If no exception has occurred yet,
-     * this method does nothing.
-     */
-    virtual void throwLocalException() const = 0;
-
-    /**
-     * Determines whether the request was sent synchronously.
-     * @return True if a request was written to the client-side transport without first being queued.
-     * If the request was initially queued, sentSynchronously returns false (independent of whether
-     * the request is still in the queue or has since been written to the client-side transport).
-     */
-    virtual bool sentSynchronously() const = 0;
-
-    /**
-     * Obtains the cookie that was passed to the begin_ method.
-     * @return The cookie, or nil if you did not pass a cookie to the begin_ method.
-     */
-    virtual LocalObjectPtr getCookie() const = 0;
-
-    /**
-     * Obtains the name of the operation.
-     * @return The operation name.
-     */
-    virtual const std::string& getOperation() const = 0;
-
-    /// \cond INTERNAL
-    virtual bool _waitForResponse() = 0;
-    virtual Ice::InputStream* _startReadParams() = 0;
-    virtual void _endReadParams() = 0;
-    virtual void _readEmptyParams() = 0;
-    virtual void _readParamEncaps(const ::Ice::Byte*&, ::Ice::Int&) = 0;
-    virtual void _throwUserException() = 0;
-
-    static void _check(const AsyncResultPtr&, const ::IceProxy::Ice::Object*, const ::std::string&);
-    static void _check(const AsyncResultPtr&, const Connection*, const ::std::string&);
-    static void _check(const AsyncResultPtr&, const Communicator*, const ::std::string&);
-
-    class Callback : public IceUtil::Shared
-    {
-    public:
-
-        virtual void run() = 0;
-    };
-    typedef IceUtil::Handle<Callback> CallbackPtr;
-
-    virtual void _scheduleCallback(const CallbackPtr&) = 0;
-    /// \endcond
-
-protected:
-
-    /// \cond INTERNAL
-    static void check(const AsyncResultPtr&, const ::std::string&);
-    /// \endcond
-};
-
-}
-
-#endif
-
-#endif

data/dist/ice/cpp/include/Ice/AsyncResultF.h

@@ -1,23 +0,0 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
-
-#ifndef ICE_ASYNC_RESULT_F_H
-#define ICE_ASYNC_RESULT_F_H
-
-#ifndef ICE_CPP11_MAPPING
-
-#include <IceUtil/Shared.h>
-#include <Ice/Handle.h>
-
-namespace Ice
-{
-
-class AsyncResult;
-ICE_API IceUtil::Shared* upCast(::Ice::AsyncResult*);
-typedef IceInternal::Handle<AsyncResult> AsyncResultPtr;
-
-}
-
-#endif
-#endif

data/dist/ice/cpp/include/Ice/BatchRequestInterceptor.h

@@ -1,75 +0,0 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
-
-#ifndef ICE_BATCH_REQUEST_INTERCEPTOR_H
-#define ICE_BATCH_REQUEST_INTERCEPTOR_H
-
-#include <IceUtil/Shared.h>
-#include <Ice/ProxyF.h>
-
-namespace Ice
-{
-
-/**
- * Represents an invocation on a proxy configured for batch-oneway or batch-datagram.
- * \headerfile Ice/Ice.h
- */
-class BatchRequest
-{
-public:
-
-    virtual ~BatchRequest()
-    {
-    }
-
-    /**
-     * Queues the request for an eventual flush.
-     */
-    virtual void enqueue() const = 0;
-
-    /**
-     * Obtains the size of the request.
-     * @return The number of bytes consumed by the request.
-     */
-    virtual int getSize() const = 0;
-
-    /**
-     * Obtains the name of the operation.
-     * @return The operation name.
-     */
-    virtual const std::string& getOperation() const = 0;
-
-    /**
-     * Obtains the proxy on which the batch request was invoked.
-     * @return The originating proxy.
-     */
-    virtual const Ice::ObjectPrxPtr& getProxy() const = 0;
-};
-
-#ifndef ICE_CPP11_MAPPING
-
-/**
- * The base class for a batch request interceptor. Subclasses must implement enqueue.
- * The interceptor can be installed via InitializationData.
- * \headerfile Ice/Ice.h
- */
-class BatchRequestInterceptor : public IceUtil::Shared
-{
-public:
-
-    /**
-     * Called by the Ice run time to enqueue a batch request.
-     * @param req An object representing the batch request.
-     * @param count The number of requests currently in the queue.
-     * @param size The number of bytes consumed by the requests currently in the queue.
-     */
-    virtual void enqueue(const BatchRequest& req, int count, int size) = 0;
-};
-typedef IceUtil::Handle<BatchRequestInterceptor> BatchRequestInterceptorPtr;
-
-#endif
-
-}
-
-#endif