Changes since version 3.0.1
---------------------------

- Removed removeObjectFactory() from the communicator interface.

- Removed getDefaultProperties() functions, and the global default
  properties. If you need global properties, you can easily create
  your own global variable.

- The signature of Ice.createProperties() is now:

  def createProperties(args=[], defaults=None)

  where "defaults" represents an optional set of default properties
  used to initialize the new Properties object. Ice properties 
  defined on the command line and properties defined in a
  configuration file override these default properties.

- Added ability to configure Ice thread start/stop hooks through
  InitializationData.

- Added identityToString and stringToIdentity to the Communicator
  interface.

- It is now possible to recreate a new object adapter with the same 
  name as an old adapter once waitForDeactivate() has completed on the
  old adapter.

- Added new operation Communicator::createObjectAdapterWithRouter(),
  which creates a routed object adapter. An object adapter may now
  be associated with at most one router, which is defined using this
  operation or by setting the <AdapterName>.Router property. Also
  as a result of this change, the ObjectAdapter::addRouter() and
  ObjectAdapter::removeRouter() operations have been removed.

- The Ice.initialize() function now takes an optional argument of type
  Ice.InitializationData. This class contains containing communicator
  members that may only be set during communicator initialization.
  Currently included are Properties, Logger, Stats, default context
  and the thread hooks. The initializeWithXXX functions have been
  deprecated and the setLogger(), setStats() and setDefaultContext()
  operations have been removed.

- Fixed an assertion failure in the object adapter when find is called
  for a non-existent identity.

- Added a new operation addProxies() to Ice::Router, which can return
  evicted proxies. The old operation addProxy() is now deprecated.
  Note that this is an internal interface for communications between
  clients and routers (such as Glacier2).

- The ice_timeout and ice_compress proxy methods now correctly
  override the timeout and compress flag of indirect proxy endpoints.

- Added proxy methods ice_isSecure, ice_getLocator, ice_getRouter.

- Deprecated the following proxy methods:

  ice_communicator
  ice_connection
  ice_newIdentity
  ice_newFacet
  ice_newContext
  ice_newAdapterId
  ice_newEndpoints

  These methods will be removed in the next major release. You should
  use the new methods shown below:

  ice_getCommunicator
  ice_getConnection
  ice_identity
  ice_facet
  ice_context
  ice_adapterId
  ice_endpoints

- Added requestId to Current, which allows a servant to determine
  whether an operation was invoked with oneway or twoway semantics.
  The requestId member is 0 for oneway invocations.

- AMI invocations will now reuse the connection cached with the
  proxy instead of always looking up an existing connection for
  each invocation. As a side effect of this change, AMI invocations 
  on a proxy with collocation optimization enabled will now raise
  Ice::CollocationOptimizationException.

- Added the property Ice.Default.LocatorCacheTimeout and the proxy
  method ice_locatorCacheTimeout(). If a cached endpoint is older
  than the configured cache timeout, the Ice runtime won't use
  the cached endpoint. Instead, the Ice runtime will query the
  Ice locator service to retrieve up-to-date endpoints and then update
  the locator cache. Please see the Ice manual for more information.

- Added the proxy method ice_endpointSelection, which allows an
  application to control how endpoints are selected at connection
  establishment. Two endpoint selection types are currently supported:
  Random and Ordered.

- Added the proxy method ice_connectionCached. This method allows you
  to enable or disable the caching of the connection by the proxy. By
  default, the proxy will cache the connection to avoid looking it up
  for each request. Disabling the connection caching is useful to do
  per-request load balancing: the proxy will select a connection for
  each request and the request will eventually be sent to different 
  servers.

- Performance improvements if an AMI callback object is reused with
  the same proxy.

- If several proxies share the same connection, and an operation call
  on one of the proxies causes a failure and the shared connection to
  be closed, then subsequent calls on the other proxies will try to
  establish a new connection instead of throwing an exception, even if
  retries are disabled.

- If a proxy is not configured with the -h parameter, Ice will now
  attempt to connect using all local interfaces. The loopback
  interface (127.0.0.1) will only be tried if it is the only local
  interface present.

Changes since version 3.0.0
---------------------------

- Fixed a bug where Ice plugin command line options were not parsed.

- Fixed a bug in the Slice parser that caused problems if an
  included file contained white space in the file name.

- Added IceGrid, IceStorm and Glacier2 demos.

Changes since version 2.1.2
---------------------------

- IcePy shared library has been moved into the python directory,
  removing the need to add an additional directory to your PYTHONPATH
  environment variable.

- Removed ice_default() method from proxies.

- Added the proxy method ice_connectionId, which allows an application
  to control connection reuse.

- Added the new methods Ice.initializeWithLogger() and
  Ice.initializeWithPropertiesAndLogger(), which ensure that a
  custom logger is used to record any errors during communicator
  initialization.

- Invocations on collocated servants are now supported.

- Added proxy methods to retrieve the proxy adapter id and endpoints
  (ice_getAdapterId() and ice_getEndpoints()) and to create a new
  proxy with a new adapter id or new endpoints (ice_newAdapterId() and
  ice_newEndpoints()).

- Exception stack trace information is now included when possible in
  the 'unknown' member of Ice.UnknownException and its derived types.

- Fixed compilation errors for 64-bit GCC builds.

- Added ice_communicator() to proxies. This function returns the
  communicator that was used to create the proxy.

- Added ice_toString() to proxies. This function returns the
  stringified proxy. This function can be more convenient to use than
  communicator.proxyToString() because you do not need the
  communicator to stringify a proxy that way.

- Ice.ObjectImpl is now an abstract class that cannot be instantiated.
  This change should be transparent to application code.

Changes since version 2.1.1
---------------------------

- Fixed a bug that resulted in an UnmarshalOutOfBoundsException when
  Slice definitions are reloaded.

Changes since version 2.1.0
---------------------------

- Added sequences of fixed-length elements to throughput demo.

- Added -E option to the various Slice compilers to print preprocessor
  output on stdout.

- Fixed a bug in the option parsing for Ice tools such as slice2cpp,
  slice2java, slice2cs, etc. The option parser used to incorrectly
  complain about repeated options when in fact no option was
  repeated. Also changed the parser to permit options to follow an
  argument, so

      slice2cpp -I. x.ice

  and

      slice2cpp x.ice -I.

  are now equivalent.

Changes since version 2.0.0
---------------------------

- Added support for Mac OS X 10.3.x

- Added support for stringifying generated types.

- Added support for Ice::Connection, which is accessible to servants
  from Ice::Current, and to clients from the proxy operation
  ice_connection.

- Added setDefaultContext() and getDefaultContext() to the
  Ice::Communicator interface. This allows a default context to be
  established on a communicator-wide basis. See section 29.9.3 in
  the doc.

  Added ice_defaultContext to Ice::ObjectProxy. This creates a new
  proxy that uses the default context established on the communicator.

- Modified the checkedCast member function of the generated Prx
  classes to accept an optional trailing argument of type Ice::Context.
  This makes it possible to do stateful things that require a context
  in a servant locator's activate() method.
