Release 1.0 of the ASL library/containers

Release 1.0 of the ASL library/containers

[Corey Minyard]

A new version of the ASL (Ada Structured Library) has been put on to
my web page - http://www.concentric.net/~Minyard.  The changes are not
so numerous, I have added a Btree container and cleaned up the
documentation.  This is release 1.0, the future 1.x releases will only
be bug fixes or documentation changes.

Note that I don't want this to be a one-man show.  If anyone wants to
work on this and add stuff to it, please send me the stuff!  You need
to be willing to release it under the LGPL.  Specifically, I'm looking
for general library routines, and few new containers, mathematical
routines, and graphics stuff.

After this release, I'll probably lay low for a little while and do
other stuff, like domestic duties I am ignoring :-).

The ASL containers are a set of container classes for Ada95.  See the
web page for more details.  A few library functions are now available.



                      What Is the ASL?
                      ----------------

Containers
----------

The container classes consist of the main container types: 

      Vector - A variable-sized array 
      AList - A list based upon an array.  This is good for stacks
	and queues that don't require insertions in the middle. 
      DList - A doubly linked list, also good for stacks and queues.
	This one is good at insertions in the middle. 
      Tree - An ordered binary tree, balance or unbalanced. 
      List - A singly linked list, good for traversing in order, but
	you can't go backwards. 
      Hash - A hash table.  Good for fast lookups, sets, and bags. 
      Heap - An ordered heap.  Good for finding the largest or smallest
	value in a set. 
      Graph - A standard graph.  The links are all bidirectional 
      DiGraph - A directed graph.  The links are uni-directional. 
      BTree - Good for fast lookups.  Not quite as fast as heaps, but
	more deterministic.

Containers come in three flavors: 

      Fixed - Implemented using a fixed size array.  These containers
	are guaranteed to not allocate any dynamic store for their
	operations. 
      Expandable - Implemented using a pointer to an array that will
	be reallocated as necessary. 
      Dynamic - Each node in the container is dynamically allocated. 

All containers come in all flavors, except a few do not have dynamic
flavors because it doesn't make sense.  Actually, some other
combinations don't seem to make much sense, but someone might use them
so they are provided.

All containers come in versions that use the default storage
management or allow the user to specify the storage management.

The containers are quite functional, each has a rich set of functions.
Tests and example programs are provided as well as some reasonable
documentation.

Semaphores
----------

The ASL contains several semaphore objects implemented using protected types: 

      Binary - A standard binary semaphore 
      Counting - A standard counting semaphore 
      Nested - A binary semaphore, but the same task can claim it
	multiple times.  It must be released the same number of times
	(by that task) to release the semaphore. 
      Nested_Prio - A nested semaphore, but it does priority
	inheritance.  This doesn't really work yet because setting
	dynamic priorities in Ada doesn't work immediately.  If anyone
	has an idea how to make it work, I'd like to know. 


Leak Detection Storage Manager
------------------------------

A storage manager that tracks all the allocated data and lets the user
iterate over it.  Useful for finding memory leaks.  It has found a few
for me :-).


Changelog for this release
--------------------------

Release 1.0 - 09/04/1998

* 09/02/1998 - Added a Btree container, full tests, and the like.

* 09/03/1998 - Modified makefiles to make krunching easier.

* 09/03/1998 - Converted documenation to LaTeX, did some updates.

-- 
Corey Minyard               Internet:  minyard@acm.org
  Work: minyard@nortel.ca       UUCP:  minyard@wf-rch.cirr.com