Copyright (c) 2000-2003, JYL Software Inc.

Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:

The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE, EVEN IF
JYL SOFTWARE INC. IS MADE AWARE OF THE POSSIBILITY OF SUCH DAMAGE.

Contributors:

JYL		Jacob Levy
DVM		David Van Maren
GS		Geoff Shapiro
GPS		George Peter Staplin
MK		Michael Krimerman
DAS		Daniel A. Steffen
JPF		John P. Fletcher
AKU		Andreas Kupries
JH		Jeff Hobbs
SL		Steve Landers
NCB		Nick Brawn
JM		Joe Mistachkin
JG		Jesse GrosJeans

Release: 1.0a12
	This is the twelfth release, the twelfth Alpha release. This is a
	bug fix release, with several new features.

	CONTRIBUTIONS:

	COMPATIBILITY:

	BUG FIXES:

	MODIFIED FUNCTIONALITY:

	NEW FUNCTIONALITY:

	* Added new visitor class, e4_ParentVisitor, to visit all parent
	  nodes of a given node (JYL, DVM).	

	NEW CONSTANTS, STRUTCURES, AND APIs:

	* New class e4_ParentVisitor for visiting the parent nodes of a
	  given node:

	  Constructors:

	  e4_ParentVisitor::e4_ParentVisitor();
	  e4_ParentVisitor::e4_ParentVisitor(const e4_ParentVisitor &ref);
	  e4_ParentVisitor::e4_ParentVisitor(const e4_Node &nn);

	  Destructor:

	  e4_ParentVisitor::~e4_ParentVisitor();

	  Assignment operator:

	  e4_ParentVisitor &operator=(const e4_ParentVisitor &ref);

	  Comparison operators:

	  bool e4_ParentVisitor::operator==(const e4_ParentVisitor &c) const;
	  bool e4_ParentVisitor::operator!=(const e4_ParentVisitor &c) const;

	  Is this iterator done?

	  bool e4_ParentVisitor::IsDone();

	  Is this iterator valid?

	  bool e4_ParentVisitor::IsValid();

	  Advance to the next parent:

	  bool e4_ParentVisitor::Advance();

	  Get the next parent to visit:

	  bool e4_ParentVisitor::NexParent(e4_Node &pp);

	  Get the current parent being visited:

	  bool e4_ParentVisitor::CurrentParent(e4_Node &pp);

	  Get the current parent being visited and advance the iterator
	  to the next parent to be visited:

	  bool e4_ParentVisitor::CurrentParentAndAdvance(e4_Node &pp);

	  Reset the visitor to visit all parent nodes of the given node:

	  bool e4_ParentVisitor::SetNode(const e4_Node &nn);

	MODIFIED APIs:

	INTERNAL CHANGES:

Release: 1.0a11						February 22, 2004
	This is the eleventh release, the eleventh Alpha release. This is
	a bug fix release, with several new features related to GC and
	events.

	I decided to skip 1.0a10 since Daniel Steffen released AquaTclBI
	for MacOS 10.x which contained a snapshot of the CVS repository
	and called that "e4graph 1.0a10". This way we avoid confusion
	between two different sourcebases; the 1.0a10 code in AquaTclBI
	contains several bugs that are fixed in this release.

	CONTRIBUTIONS:

	DVM and GS contributed many useful ideas, time, thought and
	discussions, regarding fixing several performance issues with
	the garbage collector.

	COMPATIBILITY:

	This release upgrades the use of expat to expat 1.95.7, released
	October 10, 2003.

	BUG FIXES:

	* Fixed a bug where GC was only happening if E4_AUTOGC was set,
	  irrespective of other modes. Now GC happens correctly when
	  other modes are set without E4_AUTOGC (JYL, DVM).

	* Fixed a bug in vertex moving if the moved vertex ended up at
	  the same index as it originated at (JYL, DAS).

	* Fixed several bugs related to vertex moving with indices that
	  are out of range. Now the semantics have been normalized to
	  mean that a target rank of 1 or 0 means that the moved vertex
	  ends up as the first vertex in the node, and target ranks larger
	  than the number of vertices in the node means that the vertex
	  ends up as the last vertex. Also, negative ranks cause the
	  moved vertex to end up as the last vertex in the node (JYL).

	* Fixed a bug with inserting with E4_IOAT when the position > 1
	  and does not exist yet in the node where the new value is
	  inserted (JYL, JG).

	* Fixed a bug that allowed use of zero and negative ranks to
	  retrieve vertices. This is now disallowed (JYL, DVM).

	* Fixed a bug where some storages could only be opened if both
	  E4_SPMODIFY and E4_SPCOMMIT were set. Now it is possible
	  to open a storage with only E4_SPMODIFY set (JYL, DVM).

	* Fixed random behavior on various platforms during vertex and
	  node detach operations due to using variables in e4_Node and
	  e4_Vertex before initialization (JYL).

	* Fixed a series of bugs with vertex movement and callbacks
	  related thereto. Now the vertex after which to move the moved
	  vertex is determined before any changes are made, so that the
	  specified rank is predictably followed. Previously the result
	  for moving a vertex within one node was not easy to predict.
	  Also, now both the node into which the vertex is inserted and
	  the node from which the vertex is removed will receive node
	  modify callbacks with the correct node modify callback reason,
	  and only one such callback is delivered if they are the same
	  node. Finally, when the vertex to be moved and the vertex at
	  which it is to be inserted are the same, no action is taken (JYL).

	* Now no longer invoking vertex add callbacks unless the new vertex
	  is returned to the user program. Previously was incorrectly
	  causing callbacks to fire for these vertices even if the program
	  did not reference them (JYL).

	* Now invoking vertex modification callbacks in all cases when the
	  modified vertex is referenced by the user program. Previously was
	  missing some cases and in other cases was invoking callbacks on
	  vertices not referenced by the user program (JYL).

	* Now invoking vertex and node modification callbacks for when user
	  data is modified (JYL, DVM).

	* Now invoking vertex and node detach callbacks in all cases when
	  the newly detached vertex or node is referenced by the user program.
	  Previously was missing some cases and in other cases was invoking
	  callbacks on vertices and nodes not referenced by the user
	  program (JYL).

	* Fixed a bug where a storage would get marked as unstable (needs to
	  be committed) when APIs that test for the existence of named vertices
	  are invoked (JYL, DVM).

	MODIFIED FUNCTIONALITY:

	* The semantics of the E4_ECDETVERTEX and E4_ECDETNODE callbacks
	  have been changed to be asynchronous. The callbacks are delivered
	  to referenced entities at detach time or some time later (JYL, DVM).

	NEW FUNCTIONALITY:

	* Enabled building and installing static versions of e4graph
	  library and test program on Unix and MacOS X 10.x. The static
	  library is named libe4graphs.a, to avoid conflicts (JYL, JG).

	* Added a timestamp mechanism that enables polling for events
	  that have occurred in the past. It is an alternative to the
	  callback mechanism (JYL, DVM).

	* Enabled user control over caching of information mapping vertex
	  names and ranks to vertices in a node. This cache is instrumental
	  in speeding up access to vertices in a node (JYL, DVM).

	* Added a permission that controls whether a storage can be
	  committed. Now you can allow a storage to be modified but prevent
	  changes from being committed. This allows you to share access
	  to a storage and make private modifications, if the storage driver
	  supports such private modifications (JYL, DVM).

	* Added a permission that controls whether the needed data
	  structures can be created in a new storage. If this permission
	  is not set, then opening a new storage will fail (DVM, JYL).

	* Added a permission that controls whether the format of a
	  storage can be updated at opening time. If a storage was
	  in the past committed by an older version of e4Graph, using
	  an older data format, then parts of the data may need to be
	  reformatted to be usable by the current library. This is done
	  automatically at opening time, if allowed by this permission.
	  If this step is needed and the permission is not given, the
	  open will fail (DVM, JYL).

	NEW CONSTANTS, STRUCTURES, AND APIs:

	* New timestamp mechanism (JYL, DVM):

	  int e4_Storage::GetTimeStamp() const

	  Retrieves the timestamp for the last recorded event. Returns
	  -1 if the storage is invalid.

	  int e4_Storage::GetTimeStampFor(int eventmask) const

	  Retrieves the timestamp for the last event that occurred and
	  whose event code is present in eventmask, which is formed by
	  OR-ing together any of the event codes defined for callbacks.
	  Returns -1 if the storage is invalid. Returns 0 if none of the
	  events whose eventcode is present in eventmask has occurred.

	  bool e4_Storage::HasOccurredSince(int timestamp, int eventmask)
		const

	  Returns true if any of the events whose event code is present in
	  eventmask have since the given timestamp. Returns false if the
	  storage is invalid, or if the timestamp is in the future or negative.
	  Use a timestamp of 0 to query whether the events have ever occurred.

	  bool e4_Storage::CauseEvent(int ec, const e4_RefCount &r,
				      void *csdata, int &timestamp)

	  Causes the event identified by ec to be reported via callbacks.
	  Also returns the timestamp for the event, in the fourth argument.

	* New APIs for controlling the caching behavior of individual
	  instances of e4_Node. Note that the global caching behavior
	  of each storage is still controlled by the storage state flag
	  E4_NOVERTEXCACHE. The caching behavior is non-persistent, so
	  it only affects the behavior of nodes referenced by the user
	  program and resets to the default when a node is not referenced.
	  Several constant flags control the behavior:

	  E4_CACHEINCREMENTAL	The default value. If this is the value
				set for a node, the cache is computed
				incrementally.
	  E4_AUTOCACHENAMES	If set, the cache of mappings from vertex
				names to vertex IDs is maintained up to
				date at all times.
	  E4_AUTOCACHERANKS	If set, the cache of mappings from vertex
				ranks to vertex IDs is maintained up to
				date at all times.

	  The above flags are managed by the following APIs:

	  int e4_Node::SetAdvisoryCachingPolicy(bool set, int mask) const
	  int e4_Node::GetAdvisoryCachingPolicy() const

	  The e4_Node::SetAdvisoryCachingPolicy call returns the previous
	  combination of flags set (JYL, DVM).

	* New event codes for events that occur during a storage lifecycle.
	  These events are not reported via callbacks; timestamps for these
	  events are however recorded (JYL, DVM):

	  E4_ECOPENSTG		The storage was opened.
	  E4_ECCOPYTOSTG	The storage was used as the target of a
				CopyTo call.
	  E4_ECCOPYFRMSTG	The storage was used as the source of a
				CopyTo call.
	  E4_ECSETSTGROOT	The root node of the storage was set to
				a new node.
	  E4_ECCOMMITSTG	The storage was committed.

	* New event mask that defines all the events that modify a storage
	  (JYL, DVM):

	  E4_ECMODSTORAGE	OR-ed combination of all the event codes
				for events that modify a storage.

	* New callback reason for vertex and node modification, for
	  denoting user data modification (JYL, DVM):

	  E4_ERMNMODUSERDATA	The user data for the given node was
				modified.
	  E4_ERMVMODUSERDATA	The user data for the given vertex was
				modified.

	* New storage permission (JYL):

	  E4_SPCOMMIT		If set, allows storage to be committed.
	  E4_SPINITIALIZE	If set, allows needed data structures to
				be created in a new storage.
	  E4_SPUPDATEFORMAT	If set, allows data structures to be
				updated from an older storage format
				if needed.

	* New node modify callback reason (JYL):

	  E4_ERNMINSVERTEX	A vertex was inserted into this node.

	MODIFIED APIs:

	* Modified storage permission constant (JYL):

	  E4_SPDEFAULTMASK	E4_SPMODIFY, E4_SPCOMMIT, E4_SPCOPYTO,
				E4_SPCOPYFROM, E4_SPINITIALIZE, and
				E4_SPUPDATEFORMAT, OR-ed together
	  E4_SPMODIFY		Now controls only whether modifications
				to the storage are allowed after opening.
				Use E4_SPUPDATEFORMAT and E4_SPINITIALIZE
				to control whether modifications are to be
				allowed during storage opening.

	INTERNAL CHANGES:

	* Fixed all errors reported by purify on Solaris (JYL).

	* Fixed several uses of variables before use; this removed random
	  platform dependent behaviors that were influenced by the value
	  of these uninitialized variables (JYL).

	* Moved all management of storage stability from the driver layer
	  to the impl layer, so that storage drivers do not have to manage
	  it, and so that the same behavior consistently exists across all
	  storage drivers (JYL).

	* Rewrote the GC mechanism and moved it into the impl layer so that
	  all drivers benefit and no driver has to implement GCs. GC is now
	  deferred by default until needed, and a partial GC is attempted
	  before a complete one is invoked, to save processing time (JYL,
	  DVM).

	* Major cleanup so that drivers do not have to be concerned with
	  issuing callbacks. All of the callback mechanism has been moved
	  into the impl layer (JYL).

Release: 1.0a9						Sep 7th, 2003
	This is the ninth release, the ninth Alpha release. This is a
	bug fix release, with few new features.

	CONTRIBUTIONS:

	Contributions of compute resources on MacOS X and FreeBSD are
	gratefully acknowledged -- thanks to NCB and JM.

	COMPATIBILITY:

	This release requires Metakit 2.4.9.2, released Feb 18, 2003.

	This release requires Tcl 8.4, if you want to build the Tcl
	binding. This release is known not to work with Tcl 8.4.3,
	because of Tcl Bug 726018 (check the bug database on
	tcl.sourceforge.net). Use Tcl 8.4.4 for best results.

	This release requires Python 2.2.3 or later, if you want to
	build the Python binding.

	BUG FIXES:

	* Fixed a bug in vertex ID caching that caused random ranks to
	  be computed (there was an uninitialized variable whose value
	  was being returned) (DVM, JYL).

	* Fixed several uninitialized variable uses (JYL, DVM).

	* Fixed a bug where the vertex cache was updated incorrectly
	  with out-of-date information after it had already been flushed
	  (JYL).

	* Fixed a bug in e4xmlbase64.c where the parsing and generation
	  of BASE64 encoded strings was not working properly on strings
	  without newlines (JYL, GS).

	* Fixed a bug in installation where the pkgIndex.tcl was not
	  being installed when building from source (JYL, GPS).

	* Binary distributions did not include the pkgIndex.tcl file so
	  it wasn't possible to package require tgraph with a binary
	  installation (JYL, GPS).

	NEW FUNCTIONALITY:

	* Added version information about the version of e4Graph that
	  wrote a storage, stored within the storage (JYL).

	NEW CONSTANTS, STRUCTURES, AND APIs:

	* New C++ APIs to return the version information for the
	  version of e4Graph that wrote a given storage (JYL):

	  static const char *e4_Storage::storage_version(const char *fname,
							 const char *dname);

	  static bool e4_Storage::storage_version_info(const char *fname,
						       const char *dname,
						       int &majver,
						       int &minver,
						       e4_ReleaeStatus &rs,
						       int &reliter);

	* New Tcl APIs to return the version string for the version
	  of e4Graph that wrote a given storage (JYL):

	  tgraph::version
		returns the version of e4Graph currently running.

	  tgraph::version storagename
		returns the version of e4Graph used to write that
		storage.

Release: 1.0a8						August 2nd, 2003
	This is the eight release, the eight Alpha release. This is a
	major feature enhancement release.

	PORTABILITY:

	This release is the first to support MacOS X 10. The build
	instructions are very similar to those for a stock Unix	system
	(DAS, JYL, SL).

	This release is the first to support an experimental Python 2.2
	binding for e4Graph, on all platforms (MK, JYL).

	COMPATIBILITY:

	This release requires Metakit 2.4.9.2, released Feb 18, 2003.

	This release requires Tcl 8.4, if you want to build the Tcl
	binding. This release is known not to work with Tcl 8.4.3,
	because of Tcl Bug 726018 (check the bug database on
	tcl.sourceforge.net). Use Tcl 8.4.4 for best results.

	This release requires Python 2.2.3. You need an installation of
	Python 2.2.3 or later if you want to build the Python binding.

	BUG FIXES:

	* Fixed several bugs in XML input/output (DAS, JPF, JYL).

	* Fixed Tcl binding crash when internal representation is lost
	  due to misuse of tgraph objects, e.g. doing "llength $mynode"
	  followed by "$mynode isvalid", which used to crash Tcl. Now
	  the command "$mynode" is invalid after the call to "llength".
	  (reported by DAS, fixed by JYL).

	* Fixed Tcl binding crash which happened when a vertex was cached
	  and became unreachable. Fixed by proper refcounting (JYL).

	* Fixed Tcl binding caching of nodes to avoid caching nodes that
	  do not have other references from the Tcl program so that the
	  node would become unreachable if detached in the storage. Prior
	  to this a node would not become unreachable and hence contained
	  vertices would not become detached, because the node was kept
	  reachable by being cached (JYL).

	* Now system callbacks happen before Tcl script callbacks in the
	  Tcl binding. Prior to this a Tcl script could see an inconsistent
	  state because the system level actions implied by the callback
	  had not yet been done (JYL).

	NEW FUNCTIONALITY:

	* Support for storage permissions. Now you can open a storage for
	  read-only access and prevent e4_Storage::CopyTo from using a
	  storage as the source and/or target for copying (GS, JYL).

	* Completely overhauled the event mechanism. Now the event mechanism
	  is generic, and there are no event-type-specific callback function
	  types -- all event callback functions have the same signature.

	  The event mechanism has also been opened up so that applications
	  using e4Graph can define their own events and cause them to occur
	  at appropriate times.

	  To facilitate this, I exposed the (pre-existing but internal)
	  event type mechanism that identifies event types as integers. User
	  programs can define new event types and obtain event type IDs,
	  and later use these IDs to cause the corresponding event type
	  to be invoked. Event type IDs for user defined events can later
	  be revoked when the event is no longer used.

	  As a result of this change, all the previous event mechanism
	  related APIs have been removed and new APIs have replaced
	  the ones that were provided in 1.0a7 (JYL).

	* New predefined event type for when a storage transitions between
	  being stable and unstable (i.e. between having all changes
	  committed and containing changes not yet committed) (JYL).

	* New APIs to define user defined event types and cause them to
	  occur (JYL).

	* Added vertex ID caching in the core, to speed up vertex lookup.
	  Previously this used to be available only to the Tcl binding,
	  and this change makes the caching available to all language
	  bindings (JYL).

	* New APIs to advance visitors without retrieving the next entity.
	  This allows writing of tight counting loops, for example (JYL,
	  DVM).

	* New API for visiting all vertices whose value is a given node
	  (DVM, JYL).

	* Support for parsing XML streams, as defined in
	  http://www.ietf.org/html.charters/xmpp-charter.html (JYL)

	MODIFIED FUNCTIONALITY:

	* Improved Unix build system, used on stock Unix systems as well
	  as on MacOS X 10.2 (JYL, DAS).

	* Removed s.IsDirty(), s.MarkDirty(). Use s.IsStable() and
	  s.MarkUnstable() instead (JYL).

	* Removed Tcl binding "storage markdirty" and "storage isdirty"
	  APIs. Instead use "storage markunstable" and "storage isstable"
	  (JYL).

	* All event-type-specific event callback function types have been
	  removed and replaced with a single event callback function type
	  (JYL).

	* Modified semantics of e4_StorageVisitor::CurrentStorage and other
	  visitor APIs that return the current entity being visited. Now the
	  APIs always return true and retrieve the current entity as long
	  as it is valid, even when the visitor is "done" (JYL, DVM).

	NEW CONSTANTS, STRUCTURES, AND APIs:

	* New storage permissions related constants. These constants
	  can be ORed together to combine permissions. If not specified,
	  the storage is opened with permissions equal to those specified
	  in E4_SPDEFAULTMASK (JYL, GS):

	  E4_SPMODIFY		If set, allows storage to be modified.
				Otherwise storage is read-only.
	  E4_SPCOPYTO		If set, allows storage to be used as
				target for CopyTo.
	  E4_SPCOPYFROM		If set, allows storage to be used as
				source for CopyTo.

	  E4_SPDEFAULTMASK	E4_SPMODIFY, E4_SPCOPYTO, E4_SPCOPYFROM
				OR-ed together

	* New constant for storage state manipulation with
	  e4_Storage::GetState and e4_Storage::SetState (JYL, GS):

	  E4_NOVERTEXCACHE	If on, this storage does not allow
				nodes to cache vertex IDs.

	* New API for pre-caching vertex IDs in a node (JYL):

	  e4_Node::PreCache() const;

	* New e4_Storage constructor for specifying permissions (JYL, GS):

	  e4_Storage::e4_Storage(const char *name,
				 const char *drivername,
				 int state,
				 int permissions);

	* New API for querying the permissions specified when the storage
	  was opened (JYL, GS):

	  int e4_Storage::GetPermissions() const;

	* New event mechanism APIs:

	  Predefined event codes:

	  E4_ECADDNODE			A new node was added to the storage.
	  E4_ECDETNODE			A node became detached.
	  E4_ECATTNODE			A node became attached.
	  E4_ECMODNODE			A node was modified.
	  E4_ECADDVERTEX		A new vertex was added to the storage.
	  E4_ECDETVERTEX		A vertex became detached.
	  E4_ECATTVERTEX		A vertex became attached.
	  E4_ECMODVERTEX		A vertex was modified.
	  E4_ECCHANGESTG		A storage became stable or unstable.

	  E4_FIRSTUSERDEFINEDEVENTCODE	Event code for first user defined
					event.
	  E4_LASTUSERDEFINEDEVENTCODE	Event code for last user defined
					event.

	  Event callback function type:

	  typedef void (*e4_CallbackFunction)(void *clientData,
					      const e4_RefCount &r,
					      void *callSiteData);

	  All callback functions registered to handle events have the
	  above signature. The first argument is a datum specified at
	  the time the callback function is registered (see below). The
	  second datum is the entity on which the event occurs. You should
	  cast it to the appropriate entity (e4_Storage, e4_Node or e4_Vertex).
	  The third datum is a value supplied by the event causing code
	  at the callsite where the event occurred. Some event codes may
	  be associated with event-type-specific data that is passed from
	  the callsite to the event callback function.

	  Here's an example of a callback function that takes an e4_Node:

	  void myCB(void *clientData, const e4_RefCount &r, void *csData)
	  {
	      e4_Node n = (e4_Node) r;

	      if (!n.IsValid()) {
	          cerr << "Oh bother.. got an invalid node\n";
	      }
	      DoSomethingWith(n);
	  }

	  Callbacks are associated with specific events via the following
	  APIs:

	  bool e4_Storage::DeclareCallback(int eventCode,
					   e4_CallbackFunction fn,
					   void *clientData);
	  bool e4_Storage::DeleteCallback(int eventCode,
					  e4_CallbackFunction fn,
					  void *clientData);

	  Events are caused by the calling the following API on a storage:

	  bool e4_Storage::CauseEvent(int eventCode,
				      const e4_RefCount &r,
				      void *callSiteData);

	  User code cannot cause events for predefined event codes. Doing
	  so will make the API return false.

	  User defined event codes are managed using the following API:

	  static bool e4_Storage::DefineEventCode(int &eventCode);
	  static bool e4_Storage::UndefineEventCode(int eventCode);
	  static bool e4_Storage::IsEventCodeDefined(int eventCode);

	  To define a new event code for use by your application, call
	  DefineEventCode. The output parameter eventCode will be set to
	  an integer value that can be used in a call to CauseEvent. Event
	  codes are defined for all storages.

	  The DefineEventCode API normally returns true; if there are no
	  more available event codes (i.e. the next event code that would
	  be allocated is larger than E4_LASTUSERDEFINEDEVENTCODE) then
	  DefineEventCode returns false.

	  User applications cannot undefine predefined event codes. Doing
	  so will make UndefineEventCode return false.

	  User applications can use IsDefineEventCode to detect whether
	  an event code is defined (JYL).

	* New enumeration for the reasons a node modification event occurs:

	  typedef enum e4_ModNodeEventReason {
		E4_ERMNADDVERTEX,
		E4_ERMNDETVERTEX,
		E4_ERMNRENVERTEX,
		E4_ERMNMOVVERTEX
	  } e4_ModNodeEventReason;

	  A value in this enumeration is passed as the callSiteData
	  parameter for callback functions registered for E4_ECMODNODE
	  events (JYL).

	* New constructors for e4_VertexVisitor to select visiting all
	  vertices that have a certain node as their value (all "parent
	  vertices"):

	  e4_VertexVisitor::e4_VertexVisitor(const e4_Node &child,
					     const e4_Node &parent,
					     e4_DetachChoice dc);
	  e4_VertexVisitor::e4_VertexVisitor(const e4_Node &child,
					     const e4_Node &parent,
					     e4_DetachChoice dc,
					     const char *nm);

	* New method of e4_VertexVisitor to reset an iterator to visit
	  vertices that have a given node as their value:

	  e4_VertexVisitor::SetParentVertex(const e4_Node &child,
					    const e4_Node &parent,
					    e4_DetachChoice dc,
					    const char *nm);

	* New visit method added to the e4_VisitMethod enumeration: the
	  E4_VMPARENT visit method causes an e4_VertexVisitor to visit
	  vertices that have a given node as their value:

	  typedef enum e4_VisitMethod {
		E4_VMUNKNOWN,
		E4_VMSTORAGE,
		E4_VMNODE,
		E4_VMNODERANDOM,
		E4_VMPARENT
	  } e4_VisitMethod;

	* New enumeration for the reasons a vertex modification event occurs:

	  typedef enum e4_ModVertexEventReason {
		E4_ERMVMODVALUE,
		E4_ERMVRENAME,
		E4_ERMVREPARENT,
		E4_ERMVDETVERTEX
	  } e4_ModVertexEventReason;

	  A value in this enumeration is passed as the callSiteData
	  parameter for callback functions registered for E4_ECMODVERTEX
	  events (JYL).

	* New APIs for retrieving the vertices in a parent that contain
	  a specific child node as their value (JYL, DVM):

	  bool e4_Node::GetVertexRefFromParent(int nth,
					       int ith,
					       e4_Vertex &v) const;
	  bool e4_Node::GetVertexRefFromParent(e4_Node p,
					       int ith,
					       e4_Vertex &v) const;

	* New APIs to advance visitors to the next entity without retrieving
	  it, for writing tight loops (JYL, DVM):

	  bool e4_StorageVisitor::Advance();
	  bool e4_NodeVisitor::Advance();
	  bool e4_VertexVisitor::Advance();

	* New APIs for retrieving the rank and name of vertices in a parent
	  that contain a child node as their value (JYL, DVM):

	  int e4_Node::GetRankInParent(int nth, int ith) const;
	  int e4_Node::GetRankInParent(e4_Node p, int ith) const;
	  const char *e4_Node::GetNameInParent(int nth, int ith) const;
	  const char *e4_Node::GetNameInParent(e4_Node p, int ith) const;

	* New APIs to manage an event fired when a vertex is completely
	  parsed, in e4XML:

	  bool e4_XMLParser::DeclareVertexCompletionCallback(
						e4_CallbackFunction fn,
						void *clientData);
	  bool e4_XMLParser::DeleteVertexCompletionCallback(
						e4_CallbackFunction fn,
						void *clientData);
	  bool e4_XMLParser::CauseVertexCompletionEvent(
						const e4_Vertex &v,
						void *csdata);

	  This allows the implementation of stream-oriented XML parsing
	  protocols such as those proposed by the Jabber project (see e.g.
	  http://www.ietf.org/html.charters/xmpp-charter.html) (JYL)

	* New enumeration defining the possible release status codes (JYL):

	  typedef enum e4_ReleaseStatus {
		E4_ALPHARELEASE,
		E4_BETARELEASE,
		E4_FINALRELEASE,
		E4_PATCHRELEASE
	  } e4_ReleaseStatus;

	* New APIs to return the numeric parts of the release name:

	  static int e4_Storage::major_version() const;
	  static int e4_Storage::minor_version() const;
	  static e4_ReleaseStatus e4_Storage::release_status() const;
	  static int e4_Storage::release_iteration() const;

	  These static functions can be used by language bindings and
	  clients using e4Graph to determine whether they are bound to
	  a suitable version of the package, and to select which features
	  to use (JYL).

	* New Tcl API for registering an event callback scripts when a
	  storage becomes stable or unstable.

	  $storage callback add storage change <script>

	* New Tcl APIs for managing user defined events:

	  tgraph::event define
	  tgraph::event isdefined eventcode
	  tgraph::event undefine eventcode

	  These three APIs manage the lifetime of user defined event
	  codes.

	* New TCL API for pre-caching vertex IDs in a node (JYL):

	  $node precache	

	REMOVED APIs:

	* The entire API and set of types, constants and enumeration values
	  for the event mechanism from 1.0a7 has been removed (JYL).

	* C++ APIs for "dirty" flag management have been removed (JYL):

	  bool e4_Storage::IsDirty() const;
	  bool e4_Storage::MarkDirty() const;

	* Tcl binding APIs "storage isdirty" and "storage markdirty" were
	  replaced by "storage isstable" and "storage markunstable" (JYL).

	* The following C++ APIs have been removed because they do not work
	  reliably (MK, JYL):

	  bool e4_Node::SetVertexTransientUserData(const char *name, void *ud)
		const;
	  bool e4_Node::SetVertexTransientUserData(const char *name,
						   int nth,
						   void *ud)
		const;
	  bool e4_Node::GetVertexTransientUserData(const char *name,
						   void *&ud)
		const;
	  bool e4_Node::GetVertexTransientUserData(const char *name,
						   int nth,
						   void *&ud)
		const;
	  bool e4_Node::SetVertexTransientUserDataByRank(int rank,
							 void *ud)
		const;
	  bool e4_Node::GetVertexTransientUserDataByRank(int rank,
							 void *&ud)
		const;

	MODIFIED APIs:

	* All event mechanism related functionality has changed.
	  See above (JYL).

	DEPRECATED APIs:

	* The Tcl APIs to dispose of a tgraph object are deprecated. They
	  will be removed in the first Beta release (JYL):

	  $storage dispose
	  $node dispose
	  $vertex dispose

	INTERNAL CHANGES:

	* Opened up the event mechanism so that user applications can now
	  define their own event codes and cause events to occur (JYL).

	* Streamlined Tcl binding caching behavior of nodes so that nodes are
	  cached only as long as the Tcl program holds a reference. This was
	  needed so that contained vertices would become detached if the node
	  became unreachable; previously they would not become detached
	  because the node was still referenced through the cache (JYL).

	* Only one C level callback is ever registered for any Tcl callback
	  even if both system level callbacks and Tcl script callbacks are
	  registered. This is much more efficient because only one roundtrip
	  for each callback kind is required (JYL).

	* Cleaned up visitors to coherently manage the "done" state and to
	  always return the current entity irrespective of the "done"
	  state (JYL, DVM).

	* Reorganized Metakit storage driver to streamline and clean up the
	  driver interface (JYL).

Release: 1.0a7						January 3rd, 2003
	This is the seventh release, the seventh Alpha release.

	COMPATIBILITY:

	This release requires Metakit 2.4.8. To build e4Graph 1.0a7
	you must upgrade to Metakit 2.4.8. We advise this anyway
	even if you do not plan to use e4Graph as it is the most
	stable release of Metakit yet and it fixes several important 
	and serious problems.

	This release uses Expat 1.95.5 or earlier on Unix systems, and
	requires Expat 1.95.5 on Win32 systems. To build e4Graph 1.0a7
	you must upgrade to Expat 1.95.5.

	This release contains an optional Java binding that requires
	Java 1.3.0 or later on Unix, and Java 1.4.0 on Win32 systems.

	The Tcl binding in this release is based on Tcl Stubs. It will
	compile against any Tcl release newer than 8.1. On Win32 the
	VC++ project file requires Tcl 8.4.0.

	BUG FIXES:

	* Fixed several bugs in encoding XML output for string and
	  binary valued vertices (JYL, GS).

	* Fixed several bugs in base64 encoding and decoding (JYL, GS).

	* Modifying user data attached to nodes and vertices now marks
	  the storage as dirty and will cause a commit on the e4_Storage
	  going out of scope (JYL, GS).

	* Fixed a bug in committing versus unreferenced detached entities.
	  Under some circumstances the storage was not getting marked
	  dirty when detaching vertices (and nodes), and subsequent
	  commits would preserve these detached unreachable entities
	  (JYL, GS).

	* Fixed a bug where a storage was not getting marked dirty if
	  a vertex is renamed, and in several other cases (JYL, GS).

	* Fixed a major refcounting bug in callbacks. This would cause
	  memory corruption for e4_Node::AddNode() and friends (JYL).

	* Fixed a bug in e4_Storage destructor to not depend on order
	  of destruction (JYL, JPF).

	* Fixed a bug in GC where a node held by the program wasn't properly
	  marked detached if found to be otherwise unreacahble (JYL, DVM).

	* Fixed several bugs with detaching an attaching nodes and vertices
	  after they'd been detached (JYL, DVM).

	* In Tcl binding now checking for detached vertices before using
	  a vertex as a stored procedure, because a detached vertex does
	  not have a containing node and hence cannot be used as a stored
	  procedure (JYL).

	* Fixed bug in Tcl binding to do with detaching versus caching. It
	  would not properly GC a node or vertex that was cached even though
	  the program no longer held a reference, under some circumstances
	  (JYL).

	* Documentation bug: completed the documentation of e4_VertexVisitor
	  to also show all the constructors and methods, not just some of
	  them (JYL).

	NEW FUNCTIONALITY:

	* Complete Java binding for Storage, Node, Vertex and iterators.
	  still to do: event notification. Built successfully on Linux,
	  Solaris and Win32, with Java 1.2.1, 1.3.1, 1.4.0 and 1.4.1 (JYL).

	* The node and vertex visitor classes e4_NodeVisitor and
	  e4_VertexVisitor have been enhanced to enable selective visit
	  of detached, attached or both kinds of nodes and vertices (JYL).

	* XML parsing has been refactored into three classes, to allow
	  more versatile redefinition of the parser's behavior for
	  clients that need behavior different from the default (JYL, GS).

	* XML output has been refactored into three classes, to allow
	  more versatile redefinition of the output generator's behavior
	  for clients that need behavior different from the
	  default (JYL, GS).

	* New event kind, node modification. This event is delivered if
	  subscribed, when a node changes in some significant way:

	  - A vertex in this node is renamed.
	  - A vertex in this node is deleted
	  - A new vertex is added to this node.
	  - A vertex in this node is moved.

	  Language bindings can use this event to automatically invalidate
	  any cached information about a node that may become invalid (JYL).

	* New event kind, vertex modification. This event is delivered if
	  subscribed, when a vertex changes in some signification way:

	  - The vertex is renamed.
	  - The value of the vertex is modified.

	  Language bindings can use this event to automatically invalidate
	  any cached information about a vertex that may become invalid (JYL).

	* Tcl XML binding can now specify whether to produce pure or enhanced
	  XML, like the C++ binding (JPF, JYL).

	* The Tcl binding command tgraph::transfer has been deleted and
	  and instead a new sub-command "share" is provided by storage
	  objects. Now a storage can be shared among more than one
	  interpreter and changes made in one interpreter are immediately
	  visible in other interpreters that have access to the same storage.
	  Event delivery has been enhanced to deliver events to all
	  interpreters that share access to a storage (JYL).

	* XML output now contains new __nodeuserdata__ and __vertexuserdata__
	  attributes that represent user data values attached to nodes and
	  vertices, respectively. These values are also parsed properly when
	  given in XML input (JYL, GS).

	* XML input and output for new entity kinds: DTD, namespace decl,
	  unparsed entity, notation decl, skipped entity; still needs to
	  be documented (JYL, GS).

	MODIFIED FUNCTIONALITY:

	* The constructors of e4_NodeVisitor and e4_VertexVisitor
	  now create visitors that visit only attached entities. In the
	  case of e4_NodeVisitor, the visitor visits the root node even
	  if it is detached, in addition to attached nodes. There are
	  new APIs to explicitly visit detached entities (JYL).

	* The Tcl binding now causes callbacks only for entities exported
	  to Tcl. Previously it was causing callbacks for all entities,
	  whether or not they were exported. This incurred creation and
	  destruction of entities when the program hadn't expressed an
	  interest in them (by exporting them to Tcl) and hurting the
	  Tcl binding's performance (JYL).

	* Tcl binding now converted to using GO extension mechanism so as
	  to not conflict with other uses of the ptr2 field in Tcl_Obj.
	  The implementation contains two uses of the ptr2 field (for nodes
	  and vertices) demonstrating that there is no conflict (JYL).

	* Tcl API now deprecates the dispose methods on nodes and vertices.
	  In the final e4Graph 1.0 release these methods will be removed (JYL).

	NEW APIs:

	* New enumeration for choosing which sets of entities a visitor
	  will visit:

	  typedef enum e4_DetachChoice {
		E4_DCDETACHED,
		E4_DCATTACHED,
		E4_DCBOTH
	  } e4_DetachChoice;

	  E4_DCDETACHED means to visit only detached entities; E4_DCATTACHED
	  instructs to visit only attached entities (and the root node).
	  E4_DCBOTH means to visit both attached and detached entities (JYL).

	* New APIs for visiting selected sets of nodes and vertices: attached,
	  detached, or both kinds of vertices and nodes (JYL):

	  e4_VertexVisitor::e4_VertexVisitor(const e4_Storage &s,
					     e4_DetachChoice dc);
	  e4_VertexVisitor::e4_VertexVisitor(const e4_Storage &s,
					     e4_DetachChoice dc,
					     const char *nm,
					     e4_VertexType vt);

	  bool e4_VertexVisitor::SetStorage(const e4_Storage &ss,
					    e4_DetachChoice dc);
	  bool e4_VertexVisitor::SetStorage(const e4_Storage &ss,
					    const char *nm,
					    e4_VertexType vt,
					    e4_DetachChoice dc);

	  e4_NodeVisitor::e4_NodeVisitor(const e4_Storage &ss,
					 e4_DetachChoice dc);

	  bool e4_NodeVisitor::SetStorage(const e4_Storage &ss,
					  e4_DetachChoice dc);
	

	* New XML parsing classes, used by e4_XMLParser:

	  e4_XMLInputProcessor - Checks parser state validity and
	  uses an instance of e4_XMLNodeVertexCreator (see below)
	  to make modifications to the storage.

	  e4_XMLNodeVertexCreator - Makes direct modifications to
	  the storage into which the XML input is being inserted.

	  These classes are intended to be subclassed by clients that need
	  behavior that is different from the default one. The implementation
	  of these classes retains the current semantics (JYL, GS).

	* New XML generation classes, used by e4_XMLGenerator:

	  e4_XMLOutputStream - Stream oriented interface to producing
	  XML output. This class is intended to be subclassed by
	  applications that need to send the XML output to a stream
	  oriented destination such as a file or socket.

	  e4_XMLOutputProcessor - Produces XML elements from e4Graph
	  nodes and vertices, and specially handles nodes and vertices
	  that represent equivalent special elements in the original input
	  parsed by e4_XMLParser (JYL, GS).

	* New APIs to count vertices with the same name or type as a given
	  vertex (JYL, DVM):

	  int e4_Vertex::CountWithName() const
	  int e4_Vertex::TotalCountWithName() const
	  int e4_Vertex::CountWithType() const
	  int e4_Vertex::TotalCountWithType() const

	* APIs to deal with new event kind, "node modify" (JYL):

	  typedef void (*e4_NodeModCallbackFunction)(void *cd, e4_Node n);

	  bool e4_Storage::DeclareNodeModCallback(
						e4_NodeModCallbackFunction fn,
						void *cd);
	  bool e4_Storage::DeleteNodeModCallback(e4_NodModCallbackFunction fn,
						 void *cd);

	  These APIs allow a user program to declare and delete callbacks of
	  kind "node modify" (JYL).

	* APIs to deal with new event kind, "vertex modify" (JYL):

	  typedef void (*e4_VertexModCallbackFunction)(void *cd, e4_Vertex v);

	  bool e4_Storage::DeclareVertexModCallback(
					       e4_VertexModCallbackFunction fn,
					       void *cd);
	  bool e4_Storage::DeleteVertexModCallback(
					       e4_VertexModCallbackFunction fn,
					       void *cd);
	
	* $storage share $interp $globalvarname

	  If successful then the given interpreter now has access to this
	  storage, as the value of the global variable named by the value
	  of globalvarname (JYL).

	* $storage callback add node modify <callback>

	  A "node modify" callback is now supported by the Tcl binding (JYL).

	* $storage callback add vertex modify <callback>

	  A "vertex modify" callback is now supported by the Tcl binding
	  (JYL).

	REMOVED APIs:

	* tgraph::transfer storage interp

	  The tgraph::transfer procedure is no longer supported. Use
	  $storage share $interp $varname instead (JYL).

	* tgraph::isopen storagename

	  I removed support for this functionality. User programs should
	  keep track of the storages they use and not rely on e4Graph to
	  maintain a list of open storages.

	MODIFIED APIs:

	* The optional ?-keep bool? combination on the following commands
	  is no longer supported:

	  $storage foreach vertex v cmd
	  $storage foreach node n cmd
	  $node foreach vertex v cmd

	  This change is motivated by the switchover to using Tcl objects
	  for representing nodes and vertices. If your application wants to
	  keep a vertex or node visited during iteration, just assign it to
	  a global or namespace variable under the control of your
	  application (JYL).

	* The $storage foreach command now takes an optional ?-class c?
	  combination, where c is one of "detached", "attached" or "both":

	  $storage foreach vertex v ?-class c? cmd
	  $storage foreach node n ?-class c? cmd

	  If c is ommitted, only attached entities are visited. In the case
	  of a node visitor, the root node is visited even if it is detached.

	  If c is "both", then both detached and attached entities are visited.
	  If c is "detached", only detached entities are visited. And if c is
	  "attached", only attached entities are visited (JYL).

	* The following Tcl APIs have been modified to take an optional
	  -pure <bool> pair of arguments:

	  txml::output node name ?-pure <bool>? ?-string?
	  txml::output node name ?-pure <bool>? ?-channel chanName?
	  txml::output node name ?-pure <bool>? ?-variable varName?
	  txml::output node name ?-pure <bool>? ?-append varName?

	DEPRECATED APIS:

	* In the Tcl binding prior to 1.0a7, it was necessary to specify
	  a -node option to set the value of a vertex to an existing node.
	  This was required because nodes were retrieved by name. Now that
	  nodes and vertices are true Tcl objects, this is no longer needed.

	  E4graph will continue supporting this option indefinitely because
	  there are other uses for specifying -<type>, such as distinguishing
	  between floating point and integer values.

	* The "dispose" operation on nodes and vertices is deprecated and
	  has been converted to a no-op in 1.0a7. These operations will be
	  removed in the 1.0 final release.

	INTERNAL CHANGES:

	* Garbage collection has been further sped up (JYL).

	* Event delivery has been further streamlined and rationalized (JYL).

	* The Tcl binding now uses Tcl_Obj objects throughout and relies
	  on the GenObj object model. The GenObj extension is built into
	  the Tcl binding so no user visible changes are caused by this
	  change (JYL).

	* The XML input and output facilities have been completely rewritten
	  for extensibility. Each side now factors the parsing, semantic
	  actions and actual input or output generation into three separate
	  extensible classes (JYL, GS).

Release: 1.0a6
	This is the sixth release, the sixth Alpha release.

	COMPATIBILITY:

	This release requires Metakit 2.4.6. To build e4Graph 1.0a6
	you must upgrade to Metakit 2.4.6. We advise this anyway
	even if you do not plan to use e4Graph as it is the most
	stable release of Metakit yet and it fixes several important 
	and serious problems.

	BUG FIXES:

	* Fixed a bug in e4_Storage constructor to create a valid
	  e4_Storage object only if the underlying storage was in
	  fact successfully opened (JYL).

	* Fixed Tcl callbacks; they weren't working at all in 1.0a5
	  (JYL).

	* Added on-exit handler for Tcl so that all storages are
	  closed and optionally committed when the program exits. (JYL)

	NEW FUNCTIONALITY:

	* Added Java classes, header files and some natives for new
	  proposed Java binding (JYL).

	* Added new methods to retrieve the root node from any node or
	  vertex within a storage (JPF, JYL).

	* Added new control over GC behavior: now it is possible to
	  control whether commit does a garbage collection, and whether
	  a garbage collection happens when a storage is opened and it
	  contains unreachable elements (DVM, JYL).

	* Added new control over storage preallocation: now it is possible
	  to control whether space is preallocated in big or small
	  increments. Setting the mode to do big preallocations may make
	  e4Graph more efficient when adding many entities to a storage
	  in a short period of time (DVM, JYL).

	* Added new control over storage compaction: now it is possible
	  to control whether a storage is compacted when it is closed.
	  Setting the mode to do compaction results in the smallest
	  possible disk space usage for a storage (DVM, JYL).

	* Added new events: node attach and vertex attach. Added new
	  callbacks that are called when these events occur (JYL).

	* Added new Tcl APIs to retrieve the root node from any node or
	  vertex within a storage (JYL).

	* Added new Tcl APIs to register callbacks for the new events
	  (JYL).

	* Added new facilities to the XML generation mechanism to generate
	  either pure XML or slightly marked up XML that represents any
	  circular graphs present. (JYL, JPF)

	NEW METHODS, CLASSES, TYPES AND APIS:

	e4_Storage::e4_Storage(const char *name, const char *drivername,
			       bool settings);

	This constructor allows the user program to control the initial
	settings of all controllable modes when a storage is opened
	(JYL, DVM).

	int e4_Storage::SetState(int stateMask) const;
	int e4_Storage::GetState() const;

	These methods allow the programmer to control all configurable
	behaviors through a unified interface. The SetState method
	turns on all modes for which the corresponding bit is set in
	stateMask, its argument. It retuns the previous setting of
	all controllable modes as a bitmask. The GetState method returns
	the current setting of all controllable modes as a bitmask. The
	bitmasks that can be OR-ed together to control the various modes
	are:

	E4_COMMITATCLOSE	If on, e4Graph commits the storage before
				closing it. On by default.
	E4_AUTOCOMMIT		If on, a commit is done periodically
				when changes exist in the storage. Off
				by default.
	E4_OPENGC		If on, a garbage collection is performed
				when the storage is opened. On by default.
	E4_GCBEFORECOMMIT	If on, a garbage collection is performed
				before every commit (both auto-commit and
				explicit commit). Off by default.
	E4_AUTOGC		If on, a garbage collection is performed
				whenever an entity (node or vertex) becomes
				unreachable, to reclaim all unreachable
				space in a storage. If a large number of
				changes are applied to a storage, it is
				useful to delay garbage collection until all
				changes have been applied. Turning off this
				mode will achieve that effect. On by default.
	E4_BIGPREALLOC		If on, space is preallocated in the storage
				in big increments. The default is to
				allocate storage in relatively smaller
				increments. This mode is intended for when a
				large number of entities will be created in a
				sequence of calls; this optimizes the amount
				of work that e4Graph has to do to make space
				for new enities as they are added to the
				storage. Off by default.
	E4_COMPACTATCLOSE	If on, space is compacted when the storage
				is closed. This makes the storage as small
				as possible while preserving the logical
				structure of the data graph. Off by default.

	bool e4_Node::GetRootNode(e4_Node &rn) const;
	bool e4_Vertex::GetRootNode(e4_Node &rn) const;

	These methods retrieve the root node from any node or vertex within
	a storage (JPF, JYL).

	typedef void (*e4_NodeAttCallbackFunction)(void *cd, e4_Node n);
	typedef void (*e4_VertexAttCallbackFunction)(void *cd, e4_Vertex v);

	These declarations create function types for new callback functions
	that will be invoked when a node or vertex becomes attached again
	(JYL).

	bool e4_Storage::DeclareNodeAttCallback(e4_NodeAttCallbackFunction fn,
						void *cd);
	bool e4_Storage::DeclareVertexAttCallback(
					e4_VertexAttCallbackFunction fn,
					void *cd);
	bool e4_Storage::DeleteNodeAttCallback(e4_NodeAttCallbackFunction fn,
					       void *cd);
	bool e4_Storage::DeleteVertexAttCallback(
					e4_VertexAttCallbackFunction fn,
					void *cd);

	These methods allow a user program to declare or delete callback
	functions that are invoked when a node or vertex become attached (JYL).

	e4_XMLGenerator::e4_XMLGenerator(e4_Node n, char *elementName,
					 bool exporting);
	void e4_XMLGenerator::SetExportXML(bool exporting);
	bool e4_XMLGenerator::IsExportXML() const;

	These methods allow a user program to control the behavior of an
	e4_XMLGenerator instance. If exporting is true then the generator
	will create pure XML without some additional markup that allows
	the output to represent cycles in the storage structure (JPF, JYL).

	REMOVED APIS:

	bool e4_Storage::IsGCDeferred() const;
	bool e4_Storage::SetGCDeferral(bool newval) const;

	These APIs are subsumed by the SetState and GetState APIs.

	NEW TCL APIS:

	$storage configure

	Returns the settings of all configurable modes as a list.

	$storage configure -mode

	Returns the setting of that mode.

	$storage configure -mode1 setting1 ?-mode setting?

	Sets the specified modes to the given settings. Returns the
	settings of all configurable modes as a list.

	$node root
	$vertex root

	These APIs return the root node for the storage that contains the
	node or vertex.

	$storage callback add node attach script
	$storage callback add vertex attach script
	
	These APIs declare new callbacks that will be invoked when a node
	or vertex becomes attached.

	REMOVED TCL APIS:

	$storage defergc ?newmode?

	This API is subsumed by $storage configure.

Release: 1.0a5, 02/03/2002
	This is the fifth release, the fifth Alpha release.

	BUG FIXES:

	* Fixed several bugs in reclamation of storage occuppied by
	  unreachable entities. These bugs caused storages to grow
	  (JYL).

	* Fixed several XML parsing bugs (JYL)

	* Fixed bugs in Tcl APIs (JYL).

	MODIFIED REQUIREMENTS:

	* e4Graph now requires Metakit 2.4.3. It will build from sources
	  with any release of Metakit 2.4.0 or later, but you'll have to
	  modify the Makefile or project file to achieve that result (JYL).

	NEW FUNCTIONALITY:

	* New APIs to count the number of vertices in a node that have
	  a given name, type or value. (JPF, JYL)

	* New APIs to set the value of vertices using an e4_Value
	  structure, to provide symmetry with already provided APIs that
	  return the value of a vertex as an e4_Value structure. This
	  allows programs to manipulate vertice values without having to
	  know the type of the value ahead of time. (JPF, JYL)

	* Implemented a new mechanism for detaching nodes and vertices.
	  Nodes (or vertices) that are detached are silently recycled when
	  the user program no longer has any references to them.

	  New functionality is provided to test for whether a node (or
	  vertex) is detached, and to re-attach it.

	  A new callback is provided for informing the user program when
	  a node (or vertex) it has a reference to becomes detached.
	  (DVM, JYL)

	* Each storage contains a distinguished node called the "root
	  node". Added new APIs for making a node the distinguished
	  root node and testing whether a node is the root. The root
	  node is special because it is preserved even if the user
	  program has no references to it and it is detached. (DVM, JYL)

	* Added new APIs to control when storage is reclaimed. (DVM, JYL)

	REMOVED FUNCTIONALITY:

	* Removed partially implemented support for MacOS. (JYL)

	* Removed partially implemented support for Java binding. (JYL)

	* Removed markers as a supported entity. (JYL)

	* Removed all functionality dealing with deletion of nodes (and
	  vertices and markers). Instead, now nodes (and vertices and
	  markers) are detached and when all references to the storage
	  they occupy are lost, silently recycled. (JYL)

	* Removed the callback for informing the user program when a
	  node (or vertex) is deleted from the storage. This can no longer
	  occur since the storage is preserved until the user program has
	  no more references to the node (or vertex). (DVM, JYL)

	* Storages never become empty. They always contain at least
	  the root node. (JYL)

	MODIFIED FUNCTIONALITY:

	* Nodes and vertices can become invalid (IsValid returns false)
	  in only two situations now: (a) the storage containing them
	  is closed, (b) their storage was deleted with a call to
	  e4_Storage::Delete(). (DVM, JYL)

	STORAGE FORMAT CHANGE:

	Because of the removal of marker entities, storage layout has
	changed. Storages written with older e4Graph releases are readable
	by user programs using e4Graph 1.0a5 and will be converted to the
	new format automatically. User programs using e4Graph 1.0a4
	can not read storages written by user programs using e4Graph
	1.0a5 because of this format change.

	NEW CLASSES, APIS AND DATA STRUCTURES:

	* int e4_Node::VertexCountWithName(const char *nm) const
	  int e4_Node::VertexCountWithType(e4_VertexType type) const
	  int e4_Node::VertexCountWithValue(e4_Value &v) const

	  These new APIs count the number of vertices in this node with
	  the given name, type or value. (JPF, JYL)

	* bool e4_Node::SetVertex(const char *nm, e4_Value &v) const
	  bool e4_Node::SetNthVertex(const char *nm, int i,
				     e4_Value &v) const
	  bool e4_Node::SetVertexByRank(int rank, e4_value &v) const
	  bool e4_Node::AddVertex(const char *nm, e4_InsertOrder order,
				  int &rank, e4_Value &v) const
	  bool e4_Node::AddVertexRef(const char *nm, e4_InsertOrder order,
				     int &rank, e4_Value &v,
				     e4_Vertex &f) const

	  These new APIs allow the user program to set a vertex's value
	  from an e4_Value structure and to create the vertex using an
	  e4_Value structure. (JPF, JYL)

	* bool e4_Vertex::Set(e4_Value &v) const

	  This new API allows the user program to set a vertex's value
	  using an e4_Value structure. (JPF, JYL)

	* bool e4_Storage::CreateDetachedNode(e4_Node &n) const
	  bool e4_Storage::CreateDetachedVertex(const char *nm,
						e4_Node n,
						e4_Vertex &v) const
	  bool e4_Storage::CreateDetachedVertex(const char *nm,
						int v,
						e4_Vertex &v) const
	  bool e4_Storage::CreateDetachedVertex(const char *nm,
						double d,
						e4_Vertex &v) const
	  bool e4_Storage::CreateDetachedVertex(const char *nm,
						const char *s,
						e4_Vertex &v) const
	  bool e4_Storage::CreateDetachedVertex(const char *nm,
						const void *b,
						int nb,
						e4_Vertex &v) const
	  bool e4_Storage::CreateDetachedVertex(const char *nm,
						e4_Value &vv,
						e4_Vertex &v) const

	  These new APIs allow the creation of detached nodes and
	  vertices. (DVM, JYL)

	* bool e4_Node::DetachVertex(const char *nm) const
	  bool e4_Node::DetachVertex(const char *nm, int nth) const
	  bool e4_Node::DetachVertexByRank(int rank) const
	  bool e4_Node::DetachFirstVertexWithNode(e4_Node child)

	  These new APIs allow a user program to detach a vertex from its
	  containing node. (DVM, JYL)

	* bool e4_Vertex::Detach() const

	  This new API allows a user program to detach this vertex from
	  its containing node.

	* bool e4_Node::IsDetached() const
	  bool e4_Vertex::IsDetached() const

	  These new APIs allow a user program to check whether a given
	  node or vertex to which it has a reference are detached.

	* bool e4_Storage::DeclareNodeDetachCallback(
		e4_NodeDetachCallbackFunction fn,
		void *clientData)
	  bool e4_Storage::DeleteNodeDetachCallback(
		e4_NodeDetachCallbackFunction fn,
		void *clientData)
	  bool e4_Storage::DeclareVertexDetachCallback(
		e4_VertexDetachCallbackFunction fn,
		void *clientData)
	  bool e4_Storage::DeleteVertexDetachCallback(
		e4_VertexDetachCallbackFunction fn,
		void *clientData)

	  typedef void (*e4_NodeDetachCallbackFunction)(void *, e4_Node)
	  typedef void (*e4_VertexDetachCallbackFunction)(void *, e4_Vertex)

	  These new APIs enable a user program to be informed when
	  a node or vertex becomes detached. (DVM, JYL)

	* bool e4_Node::IsRoot()

	  Returns true if this node is the distinguished root node.
	  (DVM, JYL)

	* bool e4_Storage::GetRootNode(e4_Node &n) const;
	  bool e4_Storage::SetRootNode(e4_Node n) const;

	  Allows a user program to retrieve the current root node and
	  to make another node the root node. The root node is special
	  because it is preserved even if it is detached and the user
	  program has no references to it.

	* bool e4_Storage::IsGCDeferred() const;
	  bool e4_Storage::SetGCDeferral(bool newval) const;

	  Allows a user program to find out whether storage reclamation
	  is currently deferred, and allows a user program to tell the
	  e4Graph package to defer storage reclamation for this storage.
	  (JYL)

	* void e4_Storage::DoGC() const;

	  Performs storage reclamation immediately for this storage (JYL).

	* bool e4_Storage::NeedsGC() const;

	  Returns true when this storage might contain unreachable
	  entities that whose memory can be reclaimed (JYL).

	* New Tcl APIs (JYL):

	  $storage defergc ?newval?
	  $storage needsgc
	  $storage dogc

	  Control when storage reclamation occurs.

	  $storage root ?newroot?

	  Retrieve or set the distinguished root node of a storage.

	  $storage node

	  Create a new detached vertex.

	  $storage vertex name val ?astype?

	  Create a new detached vertex.

	  $storage callback add node detach cmd
	  $storage callback add vertex detach cmd

	  Add callbacks for detach events on nodes and vertices

	  $node isroot

	  Determine whether this node is the root node.

	  $node isdetached

	  Determine whether this node is detached.

	  $node detach

	  Detaches this node from all nodes that contain it.

	  $node detachvertex vertex

	  Detaches the given vertex in this node.

	  $node detachfirstvertexwithnode node

	  Detaches the first vertex in this node that has the
	  given node as its value.

	  $vertex detach

	  Detaches this vertex from its containing node.

	  $vertex isdetached

	  Determines if this vertex is detached.

	REMOVED CLASSES, APIS AND DATA STRUCTURES:

	* Class e4_Marker and e4_MarkerVisitor are removed.

	* bool e4_Storage::MakeEmpty() const
	* bool e4_Node::MarkWith(e4_Marker m) const
	* bool e4_Node::Unmark(e4_Marker m) const
	  bool e4_Node::Unmark(int nth) const

	  These APIs are removed because markers are not a supported entity
	  anymore. (JYL)
	

	* bool e4_Marker::Delete() const
	  bool e4_Node::Delete() const
	  bool e4_Vertex::Delete() const

	  These APIs are removed because entities are no longer explicitly
	  deleted from a storage. Instead, they are detached by the user
	  program and the storage is recycled when the entity is no
	  longer referenced by the user program. (JYL)

	* bool e4_Node::DeleteVertex(const char *nm) const
	  bool e4_Node::DeleteVertex(const char *nm, int nth) const
	  bool e4_Node::DeleteVertexByRank(int rank) const
	  bool e4_Node::DeleteFirstVertexWithNode(e4_Node child)

	  These APIs are removed because vertices are no longer explicitly
	  deleted from a storage. Instead, they are detached by the user
	  program and the storage is recycled when the vertex is no longer
	  referenced by the user program. (JYL)

	* bool DeclareMarkerDelCallback(e4_MarkerDelCallbackFunction fn,
					void *clientData)
	  bool DeleteMarkerDelCallback(e4_MarkerDelCallbackFunction fn,
				       void *clientData)
	  bool DeclareNodeDelCallback(e4_NodeDelCallbackFunction fn,
				      void *clientData)
	  bool DeleteNodeDelCallback(e4_NodeDelCallbackFunction fn,
				     void *clientData)
	  bool DeclareVertexDelCallback(e4_VertexDelCallbackFunction fn,
					void *clientData)
	  bool DeleteVertexDelCallback(e4_VertexDelCallbackFunction fn,
				       void *clientData)

	  typedef void (*e4_MarkerDelCallbackFunction)(void *, e4_Marker)
	  typedef void (*e4_NodeDelCallbackFunction)(void *, e4_Node)
	  typedef void (*e4_VertexDelCallbackFunction)(void *, e4_Vertex)

	  These APIs are removed to eliminate the deletion callback
	  mechanism. (JYL)

	* Removed Tcl APIs:

	  $storage makeempty
	  $storage isempty
	  $storage marker name
	  $storage markednode name
	  $storage callback add marker delete cmd 
	  $storage callback add node delete cmd
	  $storage callback add vertex delete cmd
	  $storage foreach marker varname cmd
	  $node delete
	  $vertex delete

	  Additionally, all $marker commands are removed.

	MODIFIED APIS:

	* bool e4_Node::MoveVertex(e4_Vertex &v, e4_InsertOrder order,
				   int rank)

	  This API is modified to accept detached vertices in addition to
	  vertices that are currently within this or another node. (JYL)

	* bool e4_Vertex::MoveVertex(e4_Vertex &o, e4_InsertOrder order,
				     int offset) const

	  This API is modified to accept detached vertices in addition to
	  vertices that are currently within the node containing this
	  vertex or another node.

	  This API is modified to return false if the current vertex is
	  detached. In that case no structural changes are made to the
	  underlying storage. (JYL)

Release: 1.0a4, 08/21/2001
	This is the fourth release, the fourth Alpha.

	BUG FIXES:

	* Re-imlemented deletion mechanism completely from scratch to fix
	  severe performance issues for deletion of cyclical graphs (JYL).

	* Fixed a memory leak in the e4Graph Metakit storage driver (JYL).

	* Fixed several memory leaks in the Tcl binding of e4Graph (JYL).

	* Fixed e4_Node::SetVertex and e4_Node::SetVertexByRank; the bug
	  was that when the previous value of the vertex was a node, the
	  vertex would disappear instead of being set to a new value (DVM).

	* Fixed bug with XML parsing of character data sections; the bug
	  was that a contiguous character data section could result in a
	  series of "__data__" vertices instead of one "__data__" vertex
	  containing the entire text of the section (JPF).

	NEW FUNCTIONALITY:

	* Implemented a framework for automatically updating the format
	  of storages written by an older release to the format used by
	  the new release. This should be transparent to users. Storage
	  files written by e4Graph 1.0a3 should be readable by e4Graph
	  1.0a4 and onwards.

	  Also implemented a mechanism to detect when a storage written
	  by a newer release is read in an older release. In the future
	  this will detect e.g. when a storage written by e4Graph 1.0b1
	  is read in a client using e4Graph 1.0a4.

	* New method e4_Node::DeleteFirstVertexWithNode to delete the
	  first vertex of this node that has the argument node as its
	  value (JYL, DVM).

	* XML parsing and generation of XML comments, XML CDATA sections,
	  XML processing instructions, XML declarations, and document type
	  declarations (JYL, JPF).

	STORAGE FORMAT CHANGE:

	The storage format used by e4Graph 1.0a4 is different from that used
	by e4Graph 1.0a3. However, e4Graph 1.0a4 is able to read storages
	written by e4Graph 1.0a3 and update their format on the fly to that
	used by e4Graph 1.0a4.

	e4Graph 1.0a3 can not read storages written by e4Graph 1.0a4 
	and later.

	E4GRAPH DIRECTORY STRUCTURE REORGANIZED:

	The 'core' directory has been renamed to 'main' (DVM).

	E4GRAPH BUILD STRUCTURE REORGANIZED:

	All build output goes to builds/* by default (depending on the
	configuration options given on Unix systems; this is the
	default on win32) (JYL, DVM).

	The win32 builds leave their product in builds\win32 instead of
	in individual sub-target directories (JYL, DVM).

	E4GRAPH NOW SUPPORTS STATIC LIBRARY BUILDS ON WIN32:

	* Static libraries and static linking of executables with e4Graph
	  lead to faster execution at runtime. For example, teste4lib, the
	  statically linked API tester, is about 14% faster than teste4dll,
	  the dynamically linked API tester (DVM, JYL).
     
 	* E4_STATIC must be defined for all those who want to compile from
   	  the e4graph headers and then link to the static library. I wish
   	  this were not the case, but there was no way around it. If it is
   	  not defined, it will only link with the dll library (DVM).

   	* The 'core' project has been removed, and replaced by two new
   	  ones:
 	
 	  - e4dll   which is the dll-generating version
 	  - e4lib   which is a statically-linked version
 	
 	  In order to track this, the 'testcore' project has also been
 	  removed, and replaced by two new ones:
 	
 	  - teste4dll  which is the dll-requiring test program
 	  - teste4lib  which is a statically-linked stand-alone program
   	
 	  Note that running teste4dll requires that the e4graph and metakit
	  dynamic libraries be installed at runtime in order to work. 
	  Teste4lib, however, has statically linked in the e4graph and
	  metakit libraries, so that it does not depend on metakit or 
	  e4graph libraries to be installed at runtime (DVM).

	GENERAL BUILD CHANGES:

	* This release depends on Metakit 2.4.0 instead of on 
	  Metakit 2.3.4-29 (JYL).

	* This release depends on Expat 1.95.2 instead of on
	  Expat 1.95.1 (JYL).

	* The current project settings and Makefiles require that the 
	  Metakit source code root directory be located as a peer to
	  e4graph's root directory, and that it be called 'metakit-2.4.0'.

	  This may be easily accomplished by downloading the zip or tar
	  version of that release and unpacking it in the parent of where
	  the e4graph code is rooted. Alternatively, the CVS version of 
	  Metakit may be used if its root directory name is changed from
	  'mk' to 'metakit-2.4.0'.

	  If this is followed, the project files and Makefiles in e4graph
	  may be used without alteration (JYL, DVM).

	BUILD CHANGES ON WIN32:
	
   	* All compile output (including .pch, .obj, etc.) now goes to the
   	  'builds\win32' directory. This means that you can delete everything
   	  there, and be sure of a clean build, but also that there is NO
   	  mess left behind in the other directories. Note that it now uses
   	  the post-link step ONLY to copy the header files (DVM).
 
   	  a. all .lib and .dll files are now in 'builds\win32\lib'
   	  b. all .exe files are now in 'builds\win32\bin'
   	  c. all .h files are still in 'builds\win32\include'
   	  d. all .obj files are now in
 		 'builds\msvc\<proj>\Debug' or
   		 'builds\msvc\<proj>\Release' 
 
   	* Since the debug/release and static/dynamic versions of the files
   	  are now in the same directories, they have different names to
   	  distinguish them. The naming convention is stolen from
   	  metakit. The following is representative of the convention,
   	  covering the dynamic/static and debug/release combinations for
   	  the e4graph and teste4graph code. The others follow similar
   	  conventions (DVM).
 
   	  a. Static Release in 'builds\win32\lib\e4graphs.lib'
   	  b. Static Debug in 'builds\win32\lib\e4graphs_d.lib'
   	  c. Dynamic Release in 'builds\win32\lib\e4graph.lib/dll'
   	  d. Dynamic Debug in 'builds\win32\lib\e4graph_d.lib/dll'
   	  e. Dynamic Test Release in 'builds\win32\bin\teste4dll.exe'
   	  f. Dynamic Test Debug in 'builds\win32\bin\teste4dll_d.exe'
   	  g. Static Test Release in 'builds\win32\bin\teste4lib.exe'
   	  h. Static Test Debug in 'builds\win32\bin\teste4lib_d.exe'

Release: 1.0a3,	04/16/2001
	This is the third release.

	BUILD CHANGES:

	This release depends on Metakit 2.3.4-29 instead of on Metakit 2.01.

	The Linux binary release was built on Red Hat Linux 7.0; previous
	releases were built on Red Hat Linux 6.2.

	INCOMPATIBLE CHANGES:

	The database format used by the Metakit driver for 1.0a3 is not
	backwards compatible with the format used for 1.0a2. Databases
	output by 1.0a2 cannot be read by 1.0a3.

	NEW FUNCTIONALITY:

	Proposed Java binding included in a3 for review purposes. This
	binding is contributed by Ryan Shaw, ryan@silveregg.co.jp, and
	is made available under the same license as e4_Graph itself. The
	Java binding code is in <toplevel>/java and the documentation
	is in <toplevel>/docs/javadoc.

	The "core" and "test" parts now build on MacOS X, contributed by
	Paul Snively, psnively@earthlink.net. Currently there are only
	static libraries. Paul has reported a problem to Jean-Claude
	Wippler with the Metakit dynamic libraries in 2.3.4-29 that is
	preventing other dynamic libraries (e.g. e4_Graph) from using
	Metakit as a dynamic library. When this is fixed, Paul plans
	to make e4_Graph dynamic libraries available for MacOS X.

	The XML generated from e4_Graph storage structures now represents
	attached markers. The generator e4_XMLGenerator has been updated to
	output the attached markers, and the parser e4_XMLParser has been
	updated to restore the attached markers.

	The XML generated from cyclical e4_Graph structures is now robust
	when edited in a manner that does not preserve the order of nodes
	in the output and then read back in. Previously the position of a
	node in the output was used to calculate back references. Now, a
	node that potentially can be the target of a back reference is
	tagged with a unique (for that output) tag and any back reference
	uses the tag.

	The XML generated from e4_Graph structures is now more readable:
	each entity is presented on a new output line in the generated
	string.

	All floating point data is now represented as 64-bit values to give
	better accurracy and range. All floating point APIs have been
	updated to reflect the data size change (see below in CHANGED APIS
	AND DATA STRUCTURES).

	It is now possible to persistently associate a 32-bit integer
	quantity with each e4_Marker, e4_Node and e4_Vertex. The use and
	interpretation of this datum is entirely up to the application
	using e4_Graph. The Tcl binding reserves use of user data associated
	with vertices to represent a rich set of data types. This feature
	will be fleshed out in future releases of e4_Graph.

	It is now possible to register a callback for vertex value 
	modification. When the value of a vertex is modified in a storage
	for which callbacks are registered, all registered callback
	functions are invoked after the new value is installed.

	IMPROVED FUNCTIONALITY:

	Now using delete[] to delete strings allocated with new[]; before
	was using delete, which could lead to memory corruption on some
	platforms.

	A serious memory corruption bug in the Tcl binding, in parsing of
	vertex names, was fixed. This bug only showed up in Red Hat Linux
	7.0 and not on other platforms.

	Nodes and vertices are now deleted reliably in all circumstances.
	In previous releases it was impossible to reliably delete circular
	data structures.

	Rob Pryce identified a bug in the Tcl binding where explicitly
	specifying the type of a value to assign to a vertex would produce
	the wrong result. This bug is fixed in 1.0a3.

	The callback mechanism now generates a single callback for adding
	a vertex to a node; in past releases this could cause one or two
	callbacks, unreliably.

	All deletion callbacks occur before any change is made to the
	to-be-deleted data. Thus, for example for nodes, all vertices, 
	parents and markers are intact when the deletion callback is
	invoked. Previously, deletion callbacks were interspersed with
	actual removal of the deleted entities, resulting in an
	unpredictable environment for deletion callback functions.
	
	Tcl memory management and performance have been greatly improved.
	The Tcl binding used to retain implicitly exported vertices and cause
	memory bloat. Now, unused implicitly exported vertices are reclaimed.
	The performance of $node add, $node set, $node get and direct vertex
	access has been improved.

	Unique identifiers for e4_Graph entities such as instances of e4_Node
	are now class instances instead of integers. This enables type-safe
	comparison and type-safe retrieval of the underlying entities given
	unique identifiers representing them. Unique IDs are valid only as
	long as the underlying storage is open; the equality test fails for
	comparing unique IDs from two different storages.

	NEW CLASSES, APIS AND DATA STRUCTURES:

	New classes:

	*    class e4_CommonUniqueID
	*    class e4_MarkerUniqueID
	*    class e4_NodeUniqueID
	*    class e4_VertexUniqueID

	New APIs in class e4_Storage:

	*    bool GetMarkerFromID(e4_MarkerUniqueID mid, e4_Marker &m) const
	*    bool GetNodeFromID(e4_NodeUniqueID nid, e4_Node &n) const
	*    bool GetVertexFromID(e4_VertexUniqueID vid, e4_Vertex &v) const
	*    bool MarkerExists(const char *markername) const
	*    e4_RefKind Kind() const

	New APIs in class e4_Marker:

	*    bool SetUserData(int)
	*    bool GetUserData(int &)
	*    e4_RefKind Kind() const

	New APIs in class e4_Node:

	*    bool SetUserData(int)
	*    bool GetUserData(int &)
	*    e4_RefKind Kind() const

	New APIs in class e4_Vertex:

	*    bool SetUserData(int)
	*    bool GetUserData(int &)
	*    e4_RefKind Kind() const

	New enum e4_RefKind:

	typedef enum e4_RefKind {
	    E4_RKINVALID =		-1,
	    E4_RKSTORAGE =		0,
	    E4_RKMARKER =		1,
	    E4_RKNODE =			2,
	    E4_RKVERTEX =		3
	} e4_RefKind;

	New constant E4_INVALIDUNIQUEID.

	New Tcl APIs:

	* $storage get elementtype $id
	* $storage markerexists $markername
	* $marker id
	* $marker userdata ?newvalue?
	* $node id
	* $node parentrank $parentobj
	* $node userdata ?newvalue?
	* $vertex id
	* $vertex userdata ?newvalue?

	CHANGED APIS AND DATA STRUCTURES:
	
	All APIs to produce unique identifiers now retrieve a type-appropriate
	unique identifier instance in an output parameter, and return a
	boolean value indicating success or failure.

	In class e4_Marker:

	* old: int GetUniqueID() const;
	* new: bool GetUniqueID(e4_MarkerUniqueID &muid) const

	In class e4_Node:

	* old: int GetUniqueID() const;
	* new: bool GetUniqueID(e4_NodeUniqueID &nuid) const;

	In class e4_Vertex:

	* old: int GetUniqueID() const;
	* new: bool GetUniqueID(e4_VertexUniqueID &vuid) const;

	All APIs that took an argument of type float or returned a value
	of type float, now take an argument of type double or return a
	value of type double:

	In class e4_Node:

	* old: bool SetNthVertex(const char *nm, int nth, float f) const;
	* new: bool SetNthVertex(const char *nm, int nth, double d) const;

	* old: bool SetVertex(const char *nm, float f) const;
	* new: bool SetVertex(const char *nm, double d) const;

	* old: bool SetVertexByRank(int rank, float f) const;
	* new: bool SetVertexByRank(int rank, double d) const;

	* old: bool AddVertex(const char *nm, e4_InsertOrder order, int &rank,
			      float f) const;
	* new: bool AddVertex(const char *nm, e4_InsertOrder order, int &rank,
			      double d) const;

	* old: bool AddVertexRef(const char *nm, e4_InsertOrder order,
				 int &rank, float ff, e4_Vertex &f) const;
	* new: bool AddVertexRef(const char *nm, e4_InsertOrder order,
				 int &rank, double dd, e4_Vertex &f) const;

	* old: bool GetNthVertex(const char *nm, int nth, float &v) const;
	* new: bool GetNthVertex(const char *nm, int nth, double &v) const;

	* old: bool GetVertex(const char *nm, float &v) const;
	* new: bool GetVertex(const char *nm, double &v) const;

	* old: bool GetVertexByRank(int rank, float &v) const;
	* new: bool GetVertexByRank(int rank, double &v) const;

	In class e4_Vertex:

	* old: bool Get(float &v) const;
	* new: bool Get(double &v) const;

	* old: bool Set(float v) const;
	* new: bool Set(double v) const;

	In struct e4_Value:

	old:
	typedef struct e4_Value {
	    e4_VertexType vertexType;	/* Type of the value being passed. */
	    e4_Node n;
	    union {
		int i;
	        float f;
        	char *s;
	        e4_Binary b;
	    } u;
	} e4_Value;

	new:
	typedef struct e4_Value {
	    e4_VertexType vertexType;	/* Type of the value being passed. */
	    e4_Node n;
	    union {
		int i;
		float f;
        	char *s;
	        e4_Binary b;
	    } u;
	} e4_Value;

	In enum e4_VertexType:

	old:
	typedef enum e4_VertexType {
	    E4_VTUNKNOWN =		-1,
	    E4_VTNODE =			0,
	    E4_VTINT =			1,
	    E4_VTFLOAT =		2,
	    E4_VTSTRING =		3,
	    E4_VTBINARY =		4,
	    E4_VTLASTVERTEXTYPE =	5
	} e4_VertexType;

	new:
	typedef enum e4_VertexType {
	    E4_VTUNKNOWN =		-1,
	    E4_VTNODE =			0,
	    E4_VTINT =			1,
	    E4_VTDOUBLE =		2,
	    E4_VTSTRING =		3,
	    E4_VTBINARY =		4,
	    E4_VTLASTVERTEXTYPE =	5
	} e4_VertexType;

	CORRECTIONS:

	The Tcl API "$node rename" is actually "$node renamevertex".

Release: 1.0a2,	01/13/2001
	This is the second release.

	NEW FUNCTIONALITY:

	Support for XML input and output via Expat 1.95.1
	New e4XML (C++) and t4XML (Tcl) packages.
	e4XML package includes support for BASE64 encode/decode for transfer
	    of binary data.
	e4XML package includes support for encoding/decoding circular graphs.
	New callback facility for registering functions to be called when
	    significant changes are made to a storage.
	New statistics gathering facility that can be queried for current
	    data gathered up to that point via new APIs.
	All libraries now build with autoconf and configure on Unix. Needed
	    packages are automatically located. Support for conditional build
	    of the "tcl", "xml" and "t4xml" targets.

	IMPROVED FUNCTIONALITY:

	Fixed several crashes due to dangling pointers, buffer overruns
	    and incomplete implementations.
	Plugged several memory leaks, especially in the Tcl binding.
	Now all Tcl commands for objects that have been deleted get
	    removed instead of being left behind. This caused endless trouble
	    when the unique ID of the object that was deleted got reused.
	Improved performance of Tcl binding, especially $node call.

	NEW APIS AND DATA STRUCTURES:

	New APIs of class e4_Storage:
	*   bool CopyTo(e4_Storage, bool)
	*   bool GetMarkedNode(const char *, e4_Node &)
        *   bool GetStatistic(e4_Space, e4_SpaceStat, int &)
	*   bool DeclareMarkerAddCallback(e4_MarkerAddCallbackFunction, void *)
	*   bool DeleteMarkerAddCallback(e4_MarkerAddCallbackFunction, void *)
	*   bool DeclareMarkerDelCallback(e4_MarkerDelCallbackFunction, void *)
	*   bool DeleteMarkerDelCallback(e4_MarkerDelCallbackFunction, void *)
	*   bool DeclareNodeAddCallback(e4_NodeAddCallbackFunction, void *)
	*   bool DeleteNodeAddCallback(e4_NodeAddCallbackFunction, void *)
	*   bool DeclareNodeDelCallback(e4_NodeDelCallbackFunction, void *)
	*   bool DeleteNodeDelCallback(e4_NodeDelCallbackFunction, void *)
	*   bool DeclareVertexAddCallback(e4_VertexAddCallbackFunction, void *)
	*   bool DeleteVertexAddCallback(e4_VertexAddCallbackFunction, void *)
	*   bool DeclareVertexDelCallback(e4_VertexDelCallbackFunction, void *)
	*   bool DeleteVertexDelCallback(e4_VertexDelCallbackFunction, void *)
	New C++ classes (for the e4XML library):
	*   e4_XMLParser -- parses XML.
	*   e4_XMLGenerator -- generates XML.
	New data types:
	*   enum e4_Space
	*   enum e4_SpaceStat
	*   typedef ... e4_MarkerAddCallbackFunction
	*   typedef ... e4_MarkerDelCallbackFunction
	*   typedef ... e4_NodeAddCallbackFunction
	*   typedef ... e4_NodeDelCallbackFunction
	*   typedef ... e4_VertexAddCallbackFunction
	*   typedef ... e4_VertexDelCallbackFunction
	New Tcl APIs:
	*   tgraph::transfer storage otherinterp
	*   $storage copyto otherstorage ?forcecommit?
	*   $storage markednode markername
	*   $storage foreach vertex v script
	*   $storage foreach marker m script
	*   $storage foreach node n script
	*   $storage statistic ...
	*   $storage callback ...
	*   $node foreach marker m script
	*   $node foreach parent p script
	*   $node foreach vertex v script

	CHANGED APIS AND DATA STRUCTURES:

	C++ API void e4_Storage::Destroy() renamed to 
	    bool e4_Storage::Delete().
	Tcl API $storage destroy renamed to $storage delete.

Release: 1.0a1,	10/29/2000
	This is the first release.
	Provides core e4_Graph library package and Tcl binding.
	See the "docs" directory for HTML documentation of all APIs.
