Changes since version 1.1.0
---------------------------

- Added ice_secure/ice_isSecure, ice_datagram/ice_isDatagram,
  ice_batchDatagram/ice_isBatchDatagram proxy methods.

- 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, which cannot be set using
  stringToProxy().

- Trailing characters past the adapter id in a stringified proxy
  will now raise a ProxyParseException.

- Added ice_getAdapterId/ice_adapterId proxy methods.

- Removed most specializations of the Ice::ProtocolException local
  exception to reduce code size. Only the following specializations
  were kept:

  Ice::CloseConnectionException
  Ice::ForcedCloseConnectionException
  Ice::MarshalException
  Ice::MemoryLimitException

  The reason for the protocol error is now provided in the 'reason'
  member of Ice::ProtocolException.

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

- Removed default context support.

- Removed support for local interfaces in Slice.

- Added what() member to IceUtil::Exception, so a single catch handler
  can be used for Ice exceptions:

  try
  {
      // Call something that may throw an Ice exception
  }
  catch(const ::std::exception& ex)
  {
      cerr << ex.what() << endl; // Works for any ::std::exception,
                                 // including Ice exceptions
  }

  what() is implemented in terms of toString(), so overriding
  toString() also changes the string returned by what().

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

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

- All Ice exceptions now derive from std::exception.

- Fixed a bug where proxy operator< could return an incorrect result
  for proxies of different types (e.g., direct vs. indirect proxies).

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

- The Slice keyword 'nonmutating' is now deprecated; 'idempotent'
  should be used instead. A new metadata directive is supported for
  backward-compatibility (see below).

- New Slice metadata for operations:

  - ["cpp:const"] generates a const member function on the
    corresponding servant base class.

  - ["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 earlier versions.

- Added new overload of Ice::initialize() that accepts a StringSeq as
  the first argument.

- The ice_name() member function of exceptions derived from
  Ice::Exception (and, hence, IceUtil::Exception) now returns a
  non-const string instead of a const string:

  const ::std::string ice_name() const; // Old signature

  ::std::string ice_name() const; // New signature

- For non-abstract Slice classes, the C++ code generated now adds a
  protected destructor. This prevents accidental allocation of
  class instances on the stack or as static variables. For the
  implementation of abstract Slice classes and for servant classes
  applications can do the same thing and add a protected destructor
  to prevent non-heap allocation.

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

- The signature of createProperties(argc, argv) is now:

  PropertiesPtr createProperties(int* argc, char* argv[],
				 const PropertiesPtr& defaults = 0,
                                 const StringConverterPtr& conv = 0);

  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.

- Moved identityToString and stringToIdentity to the Communicator
  interface. 

- Added operators <=, > and >= for slice classes, proxies and 
  structures.

- Fixed an assert that could occur when a proxy received over the
  wire contained an unknown endpoint.

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

- Added communicator initialize functions that take an argument of
  type Ice::InitializationData. This structure contains communicator
  members that may only be set during communicator initialization.
  Currently included are Properties, Logger and string converters.
  The initializeWithXXX functions have been deprecated and the 
  setLogger() operation has been removed.

- Added ability to configure user-defined string and wstring
  converters that are used during marshalling/unmarshalling to
  convert between UTF8 (as required by the Ice protocol) and the
  user's character set.

- Added support for new Slice metadata ("cpp:type:wstring") that
  generates code to use std::wstring instead of std::string. See the
  Ice manual for more details.

- Added requestId to Current.


Changes since version 1.0.0
---------------------------

- Added support for the Visual C++ 2005 compiler.

- Removed the Ice.Warn.Leaks property.

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

- Added blocking client side concurrency model. The use of this model
  is controlled by the Ice.Blocking property.

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

- Fixed the marshalling of doubles on ARM/Linux.

- Added the ability to specify alternate mappings for Slice sequences
  other than std::vector. Please see the README file for more
  information.

- Fixed a bug in slice2cpp that caused one-shot constructors for
  classes to incorrectly initialize base classes for class hierarchies
  three or more levels deep.

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

- Fixed a deadlock during shutdown that could happen with
  bi-directional connections.

- Removed ice_default() method from proxies.

- Connection::close(false) (i.e., graceful connection shutdown) now
  waits until all outstanding requests have completed.

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

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

- slice2cppe now provides the --add-header option. It adds a #include
  directive for the specified header at the beginning of the generated
  source file. For example:

      slice2cppe --add-header=precompiled.h x.ice

  adds "#include <precompiled.h>" to the beginning of x.cpp (before
  any other include directives).

  You can specify an optional guard, for example:

      slice2cppe --add-header=precompiled.h,__PRECOMPILED_H__ x.ice

  With this, the beginning of x.cpp contains:

      #ifndef __PRECOMPILED_H__
      #define __PRECOMPILED_H__
      #include <precompiled.h>
      #endif

  You can repeat the --add-header option to include several headers in
  the generated source.

- Ice::Communicator::createObjectAdapter() throws
  Ice::AlreadyRegisteredException if it is called with the name of an
  object adapter that already exists.

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

- Ice-E now uses -Os rather than -O3 for optimized GCC builds.

- EVC++ release builds now use "Optimize Size".
