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<byte> for performance reasons:

  - A string is now accepted as a legal value when sequence<byte> 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<byte> 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.
