Bug 1000:

Some major changes are made in GCF/TM:
 1) GCFScheduler replaces all global GCFTask functions and variables.
 2) An event-queue is introduced
 3) Return value NEXT_STATE is added
 4) The function autoOpen is added to TCP ports
 5) 'fast' mode available for low level drivers.

Ad. 1
The GCFTask class had a lot of global functions and variables that were 
not bound to one task but were multi-task items. All these things are 
moved to a new class GCFScheduler. This class is a singleton class.
Consequence of this is that 'init', 'run' and 'stop' are not longer 
connected to the GCFTask class but are now part of the Scheduler.

old code:
	GCFTask::init(argc, argv, argv[0]);

	myTask	a("a");
	myTasl	b("b");
	a.start();
	b.start();

	GCFTask::run();

new code:
	GCFScheduler::instance()->init(argc, argv, argv[0]);

	myTask	a("a");
	myTasl	b("b");
	a.start();
	b.start();

	GCFScheduler::instance()->run();

In the same the stop function should be called with GCFScheduler::instance()->stop();


Ad. 2
The events are now stored in a queue before they are passed to the tasks. 
This has two benefits:
 - The code does not have to be re-entrant anymore because TRAN drops the 
   F_EXIT and F_ENTRY in the queue in stead of executing them during the TRAN-line.
 - The values for GCFEvent::TResult you return DO MATTER NOW. See Ad 3.

The disadvantage of the queue is that the scheduler has to make a copy of 
the event before placing it in the queue. To avoid needless copies all events
that are NO framework events (F_FSM_PROTOCOL and F_PORT_PROTOCOL) are passed 
immediately to the task. When the task returns HANDLED we save ourselves the 
effort of a copy. When anything else is returned the event is treated accordingly. See Ad 3.


Ad. 3
Since there is a queue now, the value returned by the task matters:
HANDLED: event is removed from the queue.
NEXT_STATE: event is parked on the queue until the task changes state with TRAN(...). 
After the F_ENTRY event all events that were parked with NEXT_STATE are passed 
to the task again.
NOT_HANDLED: this value will become OBSOLETE since it doesn't tell the scheduler 
what to do. FOR NOW the event will be destroyed.

Remark: In the future the return values may be extended with values like 
HOLD_x_SEC or HOLD_x_EVENTS.


Ad. 4
To simplify opening or reopening a port the function autoOpen is added to TCPPorts.
syntax: autoOpen(nrRetries, maxTimeout, reconnectInterval)

This function does several retries to setup the connection. The user can choose 
the use the nrRetries and reconnectInterval arguments or use the maxTimeout 
(and reconnectinterval) arguments:
  nrRetries        : -1 = infinite ; How often to retry the open when it fails.
  reconnectInterval: After how many seconds after a fail a reconnect attempt will be made.
  timeout          : -1 = infinite ; How long the auto-open attempts may last.

When both nrRetries and timeout are specified the condition that will be met first will 
stop the auto open sequence.

When the connection is made an F_CONNECTED events is send like open() does. When the 
connection can not be made within the given limitations a F_DISCONNECTED is returned.

Note: autoOpen(0,0) acts the same as open()


Ad. 5
Lowlevel drivers like the RSPDriver which heavily lean on FSMs (several 100's)  may 
not be happy with the eventqueue because statetransitions are handled via the queue. 
These drivers can call 'disableQueue()' after calling GCFScheduler::instance()->init(..). 
The queue mechanisme is than completely bypassed and everything works like the 
old-situation again.


Internal notes:
The boolean that the open() function returned was not really straitforward defined 
and therefor not used anywhere (as far as I know). The value that is returned now is 
true when a CONNECT or DISCONNECT message in placed in the queue and false when the 
ServiceBrokerTask needs so more time to give a result.