Changes from 0.0.0 to 0.0.1

- re did tsw_cxx.m4 macro with ac_try_compile().  tsw_cxx.m4 now requires
  AC_CC_PROG to assure C compiler is set before C++ since other tests
  will typically depend on C alone.
- added tsw_timesys.m4 for time.h and sys/time.h mapping.
- added tsw_posix.m4 for posix test and unistd.h header.
- added tsw_pthread.m4 to detect libpthread, special headers, and to 
  determine means for portable setting of recursive mutex's.
- mutex.cpp now uses tsw_pthread.m4 analysis for setting mutex attributes.
- support for library searching based on different pthread implementations
  such as the FSU, DCE, and CMA versions of Posix thread support.
- thread.cpp uses alternate thread sleeping methods such as nanosleep and
  pthread_delay_np, and pthread_yield if available.
- thread.h and event.cpp fixed for pthread_cond_init() and
  pthread_cond_destroy().
- all copyright notices added.
- configure.in added TSW_LIB_PTHREAD 

Changes from 0.0.1 to 0.0.2

- Strange problem when calling 'Exit()'.  Since a 'Final()' method is
  still on the stack, and since pthread_exit() does not continue,
  having 'Exit()' delete itself before calling pthread_exit() causes
  a problem in that the 'Final()' method is invoked after the object
  is out of scope.  To solve this, the Exit methodology has been changed
  to a 'longjmp' which returns control to a modified _exec_thread handler
  that can correctly complete Final() and self delete the object before
  exiting through pthread_exit().  This also means that threads that
  implement Run() will, if Run() has a final return, also self delete.
- Much has changed in tsw_pthread.m4 to support scanning of the header
  files for identification of the method used for recursive mutexes.
  The overall structure of tsw_pthread.m4 has been cleaned up a lot both
  to reduce the number of tests needed and to make better use of caching.
- thread.cpp and mutex.cpp updated to reflect changes in tsw_pthread.m4
- All m4 tsw_... macros now use tsw_cv_... configuration variables.
- thread.h cleaned up.  Some members of class thread now public.
- New tsw_win32.m4 added for GNU Win32 cross-compile checks.
- Socket support has been begun.

Changes from 0.0.2 to 0.0.3

- Support for signal handler based pthread_cancel() support when feature
  is missing.
- Minor typo fixes in mutex.cpp.

Changes from 0.0.3 to 0.0.4

- new THREAD_FLAGS and THREAD_LIBS substitutions to provide selective
  thread support for use in Makefiles.
- -D_REENTRANT and -D_THREAD_SAFE part of THREAD_FLAGS.
- more old pthread support, including older pthread_setcancel and
  pthread_setasynchronous support when older libpthread.
- addition of tsw_socket.m4 tests.
- general cleanup of SIGCANCEL support when cancellation is not provided.
- new tsw_signal.m4 tests for sighandler_t return type, posix, etc. 
- setCancel now supports enable and disable of cancel states as logically
  associated with cancel mode setting.
- Initial and Final routines operate in cancel disabled state.
- new getCancel() member returns current cancel setting.
- Begining of 'descriptor' classes for base of Socket and Serial.
- Ability to overide/initialize thread cancel state in Initial().

Changes from 0.0.4 to 0.0.5

- socket address classes defined.
- MutexCounter class added.
- descriptor code removed.
- freebsd compile confirmed.

Changes from 0.0.5 to 0.0.6

- The 'main' thread that represents the first thread of the application
  can now be declared as a Thread(argc, argv).  This allows the main
  application thread to be derived as a thread classed object similar
  to any other thread.  
- There can only be 'one' instance of the 'main' thread.
- One can still create threads without using a 'main' thread object, but
  if a 'main' thread object is used, it must be created before any other
  threads.
- Common signal handling is now part of the thread class.  SIGINT,
  SIGTERM, and SIGHUP are initially declared to operate in only the
  main thread, since all are typically associated with 'daemon' processes
  (SIGHUP to re-read a config, SIGTERM and SIGINT to exit).  These and
  other signals are deliberately masked during sub-thread creation.
- setSignal() used to install common and interruptible handlers.
- OnSignal() holds handler for main thread signals.
- Sleep() now uses new ape_sleep() which provides signal safe sleeping for
  threaded apps.
- yield() and wait(signo_t) introduced as global functions.
- pdetach() added to enable entry into 'daemon' mode.

Changes from 0.0.6 to 0.0.7

- InetAddress cleaned up.  InetAddress used for binding, InetHostAddress
  used for connected sockets, BroadcastAddress used for broadcasting.
- InetAddress reduced to struct in_addr.
- Socket class created, and derived for UDPSocket and TCPSocket.
- Thread now supports a copy constructor which creates a new running
  thread.  If a "main" thread is used, it may never be copied.

Changes from 0.0.7 to 0.0.8

- Socket operator= now added to allow cloning (via dup()) of sockets.  
  This and the default Socket copy constructor will probably not be
  possible under winsock, though the TCPSocket copy constructor for
  'accepting' a new client should still work.
- member naming of event and semaphore classes simplified.
- mutex and event support for win32 completed.
- thread support began under win32 (this probably brings win32 up to posix
  at 0.0.3...)
- win32 socket code in sync with current posix socket code.
- added abstract "Buffer" class for model producer/consumer buffering.

Changes from 0.0.8 to 0.0.9

- Cleanup of m4 tests so non-threaded apps can be built alongside
  threaded ones.
- Abstract Buffer class re-designed.
- GNU getopt added to libAPE if not part of native system.
- getHost and getPeer now support initial "buffer" object.
- OnAccept() added to validate remote connection requests.
- "accept" through the copy constructor now supports OnAccept() request to
  enable the server TCPSocket to reject host specific connections.

Changes from 0.0.9 to 0.0.10

- logical operators for comparing and manipulating InetAddress and
  address masks.
- OnAccept, getHost and getPeer changed.
- SubnetAddress used as address range object.

Changes from 0.0.10 to 0.0.11

- forgot read/write calls...

Changes from 0.0.11 to 0.0.12

- added peek methods for MSG_PEEK.
- all failed socket constructors now also close the socket in derived
  classes.
 
Changes from 0.0.12 to 0.0,13

- fixed win32 build tree.

Changes from 0.0.13 to 0.0.14

- found that static member functions can be starting functions for new
  threads.  _thread_exec now gone.
- more "ITC" services including Pipe and FixedBuffer classes.

Changes from 0.0.14 to 0.0.15

- fixed Signal()'s use of RETSIGTYPE in thread.h.
- win32 I/O services in pipe externalized into fileio.h to prepare for
  Serial and File classes which also require "handle" based r/w calls
  under win32.
- "posix" tree low level file access classes added.

Changes from 0.0.15 to 0.0.16

- "posix" MappedFile class added for memory mapped file support.
- Serial class added.  This brings the "posix" source tree feature
  complete.
- Write operations for direct "string" parameters added.
- A single thread at a time can now use SIGALRM for timer support

Changes from 0.0.16 to 0.1.0

- Thread now includes suspend/resume functionality.
- Socket/Serial read/write now virtualized.
- Single signals are not portable out of Posix, a lot of the 'main'
  signal support has been removed.  There is now a SignalMain() as
  well as SignalParent(), and _main is gone along with the odd
  constructors and 'OnSignal()' stuff.
- Final() removed from the Thread class; we found the Final() could never
  be called correctly from egcs virtual tables because the virtual table
  resolves purely to the base class during the destructor.  Instead,
  ~Thread() is now virtualized, and one must call Terminate() at the
  front of the 'derived' destructor.  This also means the termination
  routine now runs in the remaining threads tid rather than the
  exiting thread.

  Hence, one would now commonly use in place of Final():

  Newclass:~Newclass()
  {
	Terminate();
	cleanup code...
  }

Changes from 0.1.0 to 0.1.1

- Lock code parsing cleaned up in Serial class.
- New "isThread" member to see if current thread is this object.
- Ability to pass a "starting" semaphore for initial thread creation.
  This resolves a strange problem, at least in egcs, that, like with
  the destructor, the virtual table of the object is not usable within
  the context of the object until the constructor (starting thread)
  completes.  Also, it enables a bunch of threads to be created without
  having to be started immediately.

Change from 0.1.1 to 0.2.0

- macros.h used to hold macro functions and common definitions.
- sleep(x) translation to ape_sleep(x) now makes sleep() operate
  in seconds rather than milliseconds.  The new delay(x) can be used
  to sleep milliseconds.
- as per suggestions by Carlos, all "APE" object names are hidden with
  a "ape_" name prefix.  The APE/namespace.h file may be added as the
  last APE include item to remove prefix translation.  This substitutes
  for "namespace" support, which is not implimented in universally in
  C++ compilers, and allows libape to be linked with other class
  libraries that may already have a "Serial", "Socket", etc.
- with the addition of the ape_ prefix internally, a new library set
  is now built that is named libape rather than libAPE, and all the
  version information has been reset.
- the win32 tree uses the "APE" namespace.
- The APE Thread class usually requires a starting semaphore.  If no
  starting semaphore is passed (NULL used) then thread activation
  requires a call to the "Start()" method.  This generally assures that
  the thread is never actually started before the constructor completes.
  Start can also be given a 'starting' semaphore to use.  Start will
  fail if the thread is already started.
- The starting 'semaphore' is now the first paramater of the Thread
  class.
- For self-terminating threads, a Final() method has been re-introduced.
  The "Final" is called after the thread has been detached and is safe
  to 'terminate'.  By default, the Final method simply invokes a
  'delete this' before pthread_exit() is called by Execute().  Some
  may use Final() to bump a termination semaphore to signal the parent
  which would then delete the object after it stops, rather than have it
  self delete.  One would have to add a marker if a terminating semaphore
  is used that is shared by multiple threads to determine who actually
  has exited.
- "Readline" added to Socket and Serial classes to simplify processing
  of line oriented input.

Changes from 0.2.0 to 0.2.1
- Added "TCPSession"; a non-blocking threaded tcp socket session.
- Changes for RedHat 6.0 and improved portability.
- Changes for FreeBSD 3.1.

