NOTE: This file is no longer being updated. See the CHANGES file in the top-level directory. Changes since version 3.2.0 --------------------------- - Fixed bug where ObjectPrx.ice_getCachedConnection() would never return a valid connection object. - Fixed bug with the ObjectPrx == method where on some platforms comparison to a nil object would be incorrect. - Added the methods Ice::proxyIdentityCompare and Ice::proxyIdentityAndFacetCompare. - Implemented <=> in proxies. - Added support for protected class data members using the new metadata tag ["protected"]. The tag can be applied to a Slice class or to individual data members. - Changed the throughput demo to better support cross-language testing. - Added timeout, proxy and binding tests. - Ice::ObjectPrx::ice_getEndpointSelection now returns the correct endpoint enumeration value. - Trailing characters past the adapter id in a stringified proxy will now raise a ProxyParseException. - All local methods on a proxy that return the "same" proxy with a different attribute (such as ice_oneway and ice_secure) now return a proxy of the same class as the original. As a result, once you have downcast a proxy, it will rarely be necessary to downcast it again. For example, you can rewrite the following statements twoway = Demo::HelloPrx::checkedCast(...) oneway = Demo::HelloPrx::uncheckedCast(twoway.ice_oneway()) as simply twoway = Demo::HelloPrx::checkedCast(...) oneway = twoway.ice_oneway() The local methods ice_facet and ice_identity still return a proxy of the base class Ice::ObjectPrx, since a change to the proxy's facet or identity typically refers to an object with a different Slice type and therefore requires a new downcast. This change does not affect the behavior of existing code. However, code that depends on these new semantics will not run correctly using prior versions of Ice. - Fixed bugs in stringToProxy and propertyToProxy that reported a "NullHandleException". Changes since version 3.1.1 --------------------------- - Ice for Ruby is now compatible with ruby 1.8.1. - Fixed a bug in Application::holdInterrupt. - Fixed a bug that would cause the extension to abort if a GC occurred after the communicator was destroyed. - Fixed a code-generation bug that occurred when the name of a data member begins with an uppercase letter. - Changed the mapping of sequence for performance reasons: - A string is now accepted as a legal value when sequence is expected. An array of integers is also accepted, but the Ice run time validates every element of the array to ensure it is in the proper range, therefore using an array is much slower than using a string. - A sequence value is now always received as a string. - Added the property Ice.Default.EndpointSelection. If not defined, the default value is "Random". - Proxies can now be configured to use thread-per-connection. - Added Communicator::isShutdown() to allow applications to determine whether a communicator has been shutdown. - Added a per-process logger and two methods to get/set the logger, Ice.Util.getProcessLogger() and Ice.Util.setProcessLogger(). Calling getProcessLogger() creates a default logger if setProcessLogger() has not been called. The process logger is also used as the default logger for all communicators that do not have a logger explicitly set. - Added support for a user-defined signal handler in Ice::Application. A subclass must override the interruptCallback method and invoke callbackOnInterrupt to activate it. - Message batches are now automatically flushed when the total size of the batch reaches the message size maximum. This feature can be controlled using the Ice.BatchAutoFlush property, which is on by default. - Added Communicator::propertyToProxy() which creates a proxy from a set of properties. This operation allows you to set various local proxy settings, such as the locator cache timeout, which cannot be set using stringToProxy(). - The propertyToProxy() operation prints warnings if unknown properties are found during creation of the proxy. These warnings can be disabled by setting Ice.Warn.UnknownProperties=0. - The Ice.Logger.Timestamp property has been removed. Timestamps are now always printed. - Added the property Ice.Default.PreferSecure, which if set to 1 causes secure endpoints to be preferred over non-secure endpoints. By default this property is set to 0. Also added functions to control this behavior on a per-proxy rather than global basis: ice_isPreferSecure() and ice_preferSecure(). - If a proxy does not specify a hostname (via -h HOST), the client only attempts to connect to the loopback interface (127.0.0.1). - Attempts to change the attributes of a fixed proxy now result in a FixedProxyException rather than just ignoring the change request and returning the same proxy. Also, attempts to marshal a fixed proxy now result in a FixedProxyException rather than a MarshalException. - Added support for implicit request contexts. When you invoke an operation on a proxy and don't pass an explicit context, Ice uses the "implicit context" combined with the per-proxy context (if any). You can obtain the implicit context using the new communicator operation getImplicitContext(). Three implementations of implicit context are available; you select one by setting the property Ice.ImplicitContext to one of the following values: * None: No implicit context at all (default). * PerThread: The implementation maintains a context per thread. * Shared: The implementation maintains a single thread-safe context that is shared by all threads. - Removed defaultContext from InitializationData. - Communicator::setDefaultContext(), Communicator::getDefaultContext() and Proxy::ice_defaultContext() have been deprecated. - Added Ice.Override.Secure which forces a client to only use secure connections. - Added UnexpectedObjectException. This exception is raised if you use Slice classes and client and server are compiled with mismatched Slice definitions. Alternatively, this exception is raised if you use dynamic invocation and pass a class of the wrong type as an operation parameter. - New Slice metadata for operations: - ["nonmutating"] provides backward compatibility for idempotent operations that were previously declared using the deprecated 'nonmutating' keyword. You can replace the 'nonmutating' keyword with '["nonmutating"] idempotent' to maintain compatibility with objects implemented using Ice 3.0 or 3.1.