NOTE: This file is no longer being updated. See the CHANGES.txt file
      in the top-level directory.


Changes since version 3.1.1
---------------------------     

- slice2vb is no longer supported. To use Visual Basic .NET with Ice,
  use slice2cs to generate the stubs and skeletons in C#, and use
  a C# compiler to compile these into a DLL. Then reference that DLL
  from the Visual Basic project.

  See the manual and the demo directory for more details.

- createObjectAdapter() and propertyToProxy() print warnings if
  unknown properties are found during creation of the adapter or
  proxy. These warnings can be disabled by setting the property
  Ice.Warn.UnknownProperties=0.

- Added the property Ice.Default.EndpointSelection. If not defined,
  the default value is "Random".

- Proxies and object adapters can now be configured to use
  thread-per-connection.

- IceBox services no longer inherit the properties of the container
  by default. If this is the desired behavior set the property
  IceBox.InheritProperties to 1.

- The exception mapping now provides "one-shot" constructors that
  permit the data members of an exception to be initialized during
  construction (similar to the way class members can be initialized
  during construction).

  With this new mapping, the "Message" property of the base class
  System.ApplicationException can no longer be set; the property is
  initialized to the empty string. See the Ice Manual for more
  details.

- Ice run-time threads are now created with the IsBackground property
  set to true. This prevents Ice processes from hanging if an
  application calls Environment.Exit() without first shutting down the
  Ice run time.

- Modified the IceSSL configuration to allow the demos to run without
  administrator privileges.

- Added Communicator::isShutdown() and ObjectAdapter::isDeactivated()
  to allow applications to determine whether a communicator has been
  shutdown or an object adapter has been deactivated, respectively.

- Added destroy() operation to the ObjectAdapter interface. This
  operation must be called in order to reclaim the adapter's resources
  and be able to recreate a new adapter with the same name. Destroying
  a communicator automatically calls destroy on all of its adapters.

- 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.

- Fixed a bug in the plug-in property parsing code: if the file name of
  a plug-in included a drive letter, the plug-in did not load.

- 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.

- During the creation of an object adapter, the communicator now
  raises InitializationException if the adapter has no configuration.
  It is possible to create an adapter with no configuration, which
  is useful for bidirectional connections, by passing an empty string
  as the argument to createObjectAdapter.

- Fixed a bug that could cause the marshaling code to assert
  if Ice.MessageSizeMax was exceeded during marshaling of a string.

- It is now possible to start and stop individual IceBox services
  using the IceBox admin utility.

- 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 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().

- Added a demo to illustrate use of AMI/AMD.

- IceBox services are now stopped in the reverse order from which they 
  were started.

- 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.

- For object adapters without endpoints, Ice.Trace.Network >= 2 now
  prints a trace message.

- Added Ice.Override.Secure which forces a client to only use
  secure connections.

- Added more tracing to the IceSSL plug-in to aid in using the
  TrustOnly properties.

- Removed support for the IceBox.ServiceManager.Identity property,
  which was deprecated in Ice 3.0. The IceBox service supports an
  InstanceName property that should be used instead.

- 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.

- Passing null for a sequence parameter mapped as a collection (i.e.,
  using "clr:collection" metadata) no longer results in a
  NullReferenceException but instead causes an empty sequence to be
  sent.

- Fixed a bug where loading an Ice plug-in or an IceBox service could
  result in a System.NullReferenceException if no constructors are
  available to create the plug-in or service instance.

- 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.

- Added support for building with NMAKE.


Changes since version 3.1.0
---------------------------

- Restored Communicator::setDefaultContext.

- Fixed a bug with the IceGrid allocate and sessionAllocation demos 
  where the session would not be destroyed in the event of an 
  allocation failure.

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

- Removed removeObjectFactory() from the communicator interface.

- Generating new streaming functions for a Slice structure. The
  ice_write and ice_read member functions replace their internal
  equivalents (__write and __read).

- Added the "clr:property" directive for classes and structures.
  If used, the property causes Slice data members to be mapped
  to properties instead.

- For more information on changes in this release, see the CHANGES
  file for C#.

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

- Fixed a bug in the treatment of default contexts: proxies were
  created with an empty context instead of the default context on the
  communicator in some cases.

- Fixed a bug in the code generator that caused Clone() on sequences
  and dictionaries to behave incorrectly.

- Fixed a bug in the code generator that could cause Equals()
  comparisons to fail for containers that contained null references.

- Added ProxyIdentityKey and ProxyIdentityFacetKey helper classes to
  allow proxies to be inserted into collections and use only the
  identity, or the identity and facet name as the key. (See section
  14.11.3 in the doc.)

- Fixed a bug in endpoint comparisons that would cause new connections
  to be created needlessly. This would occur when the representation
  of the host differed between the proxy and endpoint configuration,
  with one containing the hostname and the other the numeric host
  address.

- Fixed a bug in the marshaling code that caused an exception if a
  null reference for a Slice class was passed as a parameter.

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

- Fixed a bug in slice2cs that prevented the generated code from being
  marked as CLS-compliant if the --checksum option was used.

- Added IceBox, IceGrid and IceStorm demos.

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

- Changed the mapping for Slice structures: if a Slice
  structure (recursively) contains a member that is of
  reference type, the Slice structure automatically maps
  to a VB class.

  A Slice structure now maps to a VB structure only if
  the Slice structure (recursively) consists only of
  value type (and if the "clr:class" metadata directive
  does not apply to the structure).

- The run time was obscuring the true origin (source file and
  line number) of some exceptions when rethrowing them. It
  now correctly shows the source of such exceptions
  in the stack trace.

- Added a new object adapter property, <adapter>.ReplicaGroupId, which
  allows adapters to be replicated. See the IceGrid chapter in the
  manual for more information.

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

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

- Ice will now listen on all local interfaces if no -h parameter 
  is present in the endpoint configuration and no default host has
  been set. It will also listen to all interfaces if the -h parameter
  is set to 0.0.0.0. In such configurations the endpoints published
  in proxies will not contain the loopback interface (127.0.0.1) 
  unless it is the only local interface present.

- The Equals method for Slice structures that are mapped
  to classes now returns false if the two structures being
  compared are not of the same type.

  Previously, a comparison such as

      derived.Equals(base)

  returned true if the base of part of derived was
  the same as base; with the new slice2vb compiler, this
  comparison returns false.

- The Slice mapping for sequences has been improved. The
  generated sequence class now contains the following additional
  properties and methods:

  - Capacity
  - TrimToSize
  - Sort
  - Reverse
  - BinarySearch
  - InsertRange
  - RemoveRange
  - GetRange
  - SetRange
  - LastIndexOf
  - Repeat

  These have the same semantics as the corresponding methods
  on System.Collections.ArrayList, with one exception: GetRange
  returns a true copy of the requested range instead of returning
  a view of a sub-section of the collection.

- The Ice run-time libraries are now marked as CLS-compliant
  assemblies. In addition, the generated code is now also
  CLS-compliant.

  This involves one change to the VB language mapping:

  The skeleton class used be called _<interface-name>Disp but
  is now called <interface-name>Disp_.

  For example, if you previously had:

      Public Class MyIntfI
          Inherits _MyIntfDisp
	  ' ...
      End Class

  you now have to write:

      Public Class MyIntfI
          Inherits MyIntfDisp_
	  ' ...
      End Class

  Similarly, for the Tie mapping, the location of the underscore
  has changed:

      _MyIntfTie -> MyIntfTie_

- Added support for the thread-per-connection concurrency model.

- Changed the way servant locators work if a server has a servant
  locator registered for a specific category, in addition to a default
  servant locator. Previously, if the locator for the specific category
  failed to locate the servant, the run time would then call the default
  locator. With the new behavior, if the locator for the specific category
  does not return a servant, the default locator is not called.

- slice2vb now supports a new metadata directive: ["vb:attribute"].
  This directive allows you to inject VB attribute definitions into the
  generated code. See the VB mapping chapter in the Ice manual for
  more information.

- The "vb:" metadata prefix has been replaced by the "clr:" prefix,
  so you now need to use "clr:collection" and "clr:class".
  The "vb:" prefix is still recognized and acted upon; slice2vb
  emits a warning for the old prefix. Two releases from now, the
  warning will become a hard error and "vb:" will no longer work.

- Fixed a bug in the slice2vb code generator: for sequences of
  Slice structs that used the class mapping, the generated code
  caused a run-time error.

- Fixed a bug in the slice2vb code generator: if an operation
  had a parameter named ix or spx, incorrect code was generated
  in some cases.

- 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.stringToProxy() 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.

- Added new features to the Visual Basic mapping:

  - Structures, classes, and exceptions now have one-shot
    constructors. For example, for a class

      class Example {
          int i;
	  string s;
      };

    the following constructors are generated:

      Public Class Example Inherits Ice.ObjectImpl
	  Public Sub New() ...
	  Public Sub New(ByVal i as Integer, ByVal s As String) ...

    This allows you to construct a structure, class, or exception and
    supply values for the data members in a single statement, instead
    of having to assign to the members of a default-constructed
    instance.

    For derived exceptions and classes, the constructor expects values
    for all data members, including those of base exceptions or
    classes, in base-to-derived order of declaration.

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

- Fixed a bug in the code generator: incorrect code was generated
  if an operation used an exception from an unrelated module in
  its exception specification.

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
---------------------------

- Fixed bug in the code generators for C# and VB: for sequences
  of structs and sequences of Object*, incorrect code was generated
  if a ["cs:collection"] or ["vb:collection"] metadata directive
  was used.

- 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.8.3 in the
  doc.

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

- Overloaded the checkedCast member function of the generated PrxHelper
  classes to allow a 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.

- Fixed a bug in slice2vb: incorrect code was generated if an interface
  was derived from a base interface in a different module if the base
  interface contained a AMD operation.
