Lots of files were added around '96

10 files changed, 1113 insertions, 0 deletions

diff --git a/dnn/Behaviour.cc b/dnn/Behaviour.cc
new file mode 100755
index 0000000..98a5b8d
--- /dev/null
+++ b/dnn/Behaviour.cc
@@ -0,0 +1,151 @@
+/*
+ *	DNN - Data News Network
+ *
+ *	by Stephane Chatty
+ *
+ *	Copyright 1993-1996
+ *	Centre d'Etudes de la Navigation Aerienne (CENA)
+ *
+ *	Behaviours.
+ *
+ *	$Id$
+ *	$CurLog$
+ */
+
+#include "Behaviour.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+
+DnnToken :: DnnToken ()
+{
+}
+
+DnnToken :: ~DnnToken ()
+{
+}
+
+DnnState :: DnnState (const char* name)
+: Name (name),
+  Transitions ()
+{
+}
+
+DnnState :: ~DnnState ()
+{
+	CcuListIterOf <DnnTransition> t = Transitions;
+	while (++t)
+		delete *t;
+}
+
+DnnTransition*
+DnnState :: CreateTransition (const char* name, DnnState* s, DnnActivation* a, DnnAction* aa)
+{
+	DnnTransition* t = new DnnTransition (name, this, s, a, aa);
+	Transitions.Append (t);
+	return t;
+}
+
+void
+DnnState :: Activate (DnnBehaviour* b, DnnToken* tk)
+{
+	CcuListIterOf <DnnTransition> t = Transitions;
+	while (++t) {
+		DnnBehaviourReaction* r = new DnnBehaviourReaction (b, *t);
+		(*t)->Activate (r, tk);
+		b->AddReaction (r);
+	}
+}
+
+DnnTransition :: DnnTransition (const char* name, DnnState* from, DnnState* to, DnnActivation* a, DnnAction* aa)
+: Name (name),
+  From (from),
+  To (to),
+  Activation (a),
+  Action (aa)
+{
+}
+
+DnnTransition :: ~DnnTransition ()
+{
+}
+
+void
+DnnTransition :: Activate (DnnBaseReaction* r, DnnToken* t)
+{
+	(*Activation) (r, t);
+}
+
+DnnState*
+DnnTransition :: Fire (DnnToken* tk, DnnEvent* ev)
+{
+	(*Action) (tk, ev);
+	return To;
+}
+
+DnnBehaviourModel :: DnnBehaviourModel ()
+: Initial (0),
+  States ()
+{
+}
+
+DnnBehaviourModel :: ~DnnBehaviourModel ()
+{
+	CcuListIterOf <DnnState> s = States;
+	while (++s)
+		delete *s;
+}
+
+DnnState*
+DnnBehaviourModel :: CreateState (const char* name)
+{
+	DnnState* s = new DnnState (name);
+	States.Append (s);
+	return s;
+}
+
+DnnBehaviour :: DnnBehaviour (DnnBehaviourModel& m, DnnToken* tk)
+: TheModel (&m),
+  CurState (m.GetInitial ()),
+  CurReactions (),
+  CurToken (tk)
+{
+	CurState->Activate (this, CurToken);
+}
+
+void
+DnnBehaviour :: Fire (DnnTransition* t, DnnEvent* ev)
+{
+	/* check consistency */
+	if (CurState != t->GetOrigin ()) {
+		fprintf (stderr, "incoherent state in behaviour\n");
+		abort ();
+	}
+
+	/* disactivate */
+	DnnBaseReaction* r;
+	while (r = CurReactions.RemoveFirst ())
+		delete r;
+
+	/* fire transition */
+	CurState = t->Fire (CurToken, ev);
+
+	/* activate new state */
+	CurState->Activate (this, CurToken);
+}
+
+DnnBehaviourReaction :: DnnBehaviourReaction (DnnBehaviour* b, DnnTransition* t)
+  : TheBehaviour (b),
+    TheTransition (t)
+{
+}
+
+DnnBehaviourReaction :: ~DnnBehaviourReaction ()
+{
+}
+
+void
+DnnBehaviourReaction :: Manage (DnnEvent& ev)
+{
+	TheBehaviour->Fire (TheTransition, &ev);
+}
diff --git a/dnn/Behaviour.h b/dnn/Behaviour.h
new file mode 100755
index 0000000..2db049e
--- /dev/null
+++ b/dnn/Behaviour.h
@@ -0,0 +1,104 @@
+/*
+ *	DNN - Data News Network
+ *
+ *	by Stephane Chatty
+ *
+ *	Copyright 1993-1996
+ *	Centre d'Etudes de la Navigation Aerienne (CENA)
+ *
+ *	Behaviours.
+ *
+ *	$Id$
+ *	$CurLog$
+ */
+
+#ifndef DnnBehaviour_H_
+#define DnnBehaviour_H_
+
+#include "cplus_bugs.h"
+#include "Reaction.h"
+#include "ccu/String.h"
+#include "ccu/List.h"
+
+class DnnBehaviour;
+class DnnTransition;
+class DnnEvent;
+
+class DnnToken {
+public:
+		DnnToken ();
+virtual		~DnnToken ();
+};
+
+typedef void (DnnActivation) (DnnBaseReaction*, DnnToken*);
+typedef void (DnnAction) (DnnToken*, DnnEvent*);
+
+class DnnState {
+protected:
+	CcuString	Name;
+	CcuListOf <DnnTransition>	Transitions;
+public:
+		DnnState (const char*);
+		~DnnState ();
+	DnnTransition*	CreateTransition (const char*, DnnState*, DnnActivation*, DnnAction*);
+	void	Activate (DnnBehaviour*, DnnToken*);
+	
+};
+
+class DnnTransition {
+protected:
+	CcuString	Name;
+	DnnState*	From;
+	DnnState*	To;
+	DnnActivation*	Activation;
+	DnnAction*	Action;
+
+public:
+		DnnTransition (const char*, DnnState*, DnnState*, DnnActivation*, DnnAction*);
+		~DnnTransition ();
+inline	DnnState*	GetDestination () const	{ return To;}
+inline	DnnState*	GetOrigin () const	{ return From;}
+	void	Activate (DnnBaseReaction*, DnnToken*);
+	DnnState*	Fire (DnnToken*, DnnEvent*);
+};
+
+
+class DnnBehaviourModel {
+protected:
+	DnnState*	Initial;
+	CcuListOf <DnnState>	States;
+public:
+		DnnBehaviourModel ();
+		~DnnBehaviourModel ();
+inline	DnnState*	GetInitial () const	{ return Initial; }
+inline	void	SetInitial (DnnState* s)	{ Initial = s; }
+	DnnState*	CreateState (const char* = 0);
+};
+
+class DnnBehaviour {
+friend	class	DnnBehaviourReaction;
+protected:
+	DnnBehaviourModel*	TheModel;
+	DnnState*	CurState;
+	CcuListOf <DnnBaseReaction>	CurReactions;
+	DnnToken*	CurToken;
+	void	Fire (DnnTransition*, DnnEvent*);
+public:
+		DnnBehaviour (DnnBehaviourModel&, DnnToken*);
+		~DnnBehaviour ();
+inline	void	AddReaction (DnnBaseReaction* r) { CurReactions.Append (r); }
+
+};
+
+class DnnBehaviourReaction : public DnnBaseReaction {
+protected:
+	DnnBehaviour*	TheBehaviour;
+	DnnTransition*	TheTransition;
+public:
+		DnnBehaviourReaction (DnnBehaviour*, DnnTransition*);
+		~DnnBehaviourReaction ();
+	void	Manage (DnnEvent&);
+};	
+
+#endif	/* DnnBehaviour_H_ */
+
diff --git a/dnn/Criterion.cc b/dnn/Criterion.cc
new file mode 100755
index 0000000..edef576
--- /dev/null
+++ b/dnn/Criterion.cc
@@ -0,0 +1,142 @@
+/*
+ *	DNN - Data News Network
+ *
+ *	by Stephane Chatty
+ *
+ *	Copyright 1993-1995
+ *	Centre d'Etudes de la Navigation Aerienne (CENA)
+ *
+ *	Criteria.
+ *
+ *	$Id$
+ *	$CurLog$
+ */
+
+#include "Criterion.h"
+
+DnnBaseCriterion :: DnnBaseCriterion ()
+{
+}
+
+DnnBaseCriterion :: ~DnnBaseCriterion ()
+{
+}
+
+
+DnnAndCriterion :: DnnAndCriterion ()
+: DnnBaseCriterion (),
+  Conditions ()
+{
+}
+
+DnnAndCriterion :: ~DnnAndCriterion ()
+{
+}
+
+DnnAndCriterion&
+DnnAndCriterion :: operator &= (DnnBaseCriterion& b)
+{
+	Conditions.Append (&b);
+	return *this;
+}
+
+DnnAndCriterion&
+DnnAndCriterion :: operator &= (DnnOrCriterion& b)
+{
+	Conditions.Append (&b);
+	return *this;
+}
+
+DnnAndCriterion&
+DnnAndCriterion :: operator &= (DnnAndCriterion& b)
+{
+	CcuListIterOf <DnnBaseCriterion> li = b.Conditions;
+	while (++li)
+		Conditions.Append (*li);
+	return *this;
+}
+
+bool
+DnnAndCriterion :: Test (DnnEvent& ev)
+{
+	bool res = true;
+	CcuListIterOf <DnnBaseCriterion> li = Conditions;
+	while (res && ++li)
+#ifdef CPLUS_BUG22
+		res = bool (res && (*li)->Test (ev));
+#else
+		res = res && (*li)->Test (ev);
+#endif
+	return res;
+}
+
+
+DnnOrCriterion :: DnnOrCriterion ()
+: DnnBaseCriterion (),
+  Alternatives ()
+{
+}
+
+DnnOrCriterion :: ~DnnOrCriterion ()
+{
+}
+
+DnnOrCriterion&
+DnnOrCriterion :: operator |= (DnnOrCriterion& b)
+{
+	CcuListIterOf <DnnBaseCriterion> li = b.Alternatives;
+	while (++li)
+		Alternatives.Append (*li);
+	return *this;
+}
+
+DnnOrCriterion&
+DnnOrCriterion :: operator |= (DnnBaseCriterion& b)
+{
+	Alternatives.Append (&b);
+	return *this;
+}
+
+DnnOrCriterion&
+DnnOrCriterion :: operator |= (DnnAndCriterion& b)
+{
+	Alternatives.Append (&b);
+	return *this;
+}
+
+bool
+DnnOrCriterion :: Test (DnnEvent& ev)
+{
+	bool res = false;
+	CcuListIterOf <DnnBaseCriterion> li = Alternatives;
+	while (!res && ++li)
+#ifdef CPLUS_BUG22
+		res = bool (res || (*li)->Test (ev));
+#else
+		res = res || (*li)->Test (ev);
+#endif
+	return res;
+}
+
+
+DnnBasicCriterion :: DnnBasicCriterion ()
+: DnnBaseCriterion (),
+  Check (0)
+{
+}
+
+DnnBasicCriterion :: DnnBasicCriterion (bool (*c) (DnnEvent&))
+: DnnBaseCriterion (),
+  Check (c)
+{
+}
+
+DnnBasicCriterion :: ~DnnBasicCriterion ()
+{
+}
+
+bool
+DnnBasicCriterion :: Test (DnnEvent& e)
+{
+	return Check ? (*Check) (e) : false;
+}
diff --git a/dnn/Criterion.h b/dnn/Criterion.h
new file mode 100755
index 0000000..92dd48a
--- /dev/null
+++ b/dnn/Criterion.h
@@ -0,0 +1,103 @@
+/*
+ *	DNN - Data News Network
+ *
+ *	by Stephane Chatty
+ *
+ *	Copyright 1993-1995
+ *	Centre d'Etudes de la Navigation Aerienne (CENA)
+ *
+ *	Criteria.
+ *
+ *	$Id$
+ *	$CurLog$
+ *	Removed pragma interfaces
+ */
+
+#ifndef DnnCriterion_H_
+#define DnnCriterion_H_
+
+#include "cplus_bugs.h"
+#include "ccu/bool.h"
+#include "ccu/List.h"
+class DnnEvent;
+
+class DnnBaseCriterion {
+friend	class	DnnAndCriterion;
+friend	class	DnnOrCriterion;
+protected:
+		DnnBaseCriterion ();
+		~DnnBaseCriterion ();
+public:
+virtual	bool	Test (DnnEvent&) = 0;
+};
+
+class DnnOrCriterion;
+
+class DnnAndCriterion : public DnnBaseCriterion {
+friend	class	DnnOrCriterion;
+protected:
+	CcuListOf <DnnBaseCriterion>	Conditions;
+	bool	Test (DnnEvent&);
+public:
+		DnnAndCriterion ();
+		~DnnAndCriterion ();
+	DnnAndCriterion&	operator &= (DnnBaseCriterion&);
+	DnnAndCriterion&	operator &= (DnnOrCriterion&);
+	DnnAndCriterion&	operator &= (DnnAndCriterion&);
+};
+
+class DnnOrCriterion : public DnnBaseCriterion {
+friend	class	DnnAndCriterion;
+protected:
+	CcuListOf <DnnBaseCriterion>	Alternatives;
+	bool	Test (DnnEvent&);
+public:
+		DnnOrCriterion ();
+		~DnnOrCriterion ();
+	DnnOrCriterion&	operator |= (DnnBaseCriterion&);
+	DnnOrCriterion&	operator |= (DnnOrCriterion&);
+	DnnOrCriterion&	operator |= (DnnAndCriterion&);
+};
+
+class DnnBasicCriterion : public DnnBaseCriterion {
+protected:
+	bool  (*Check) (DnnEvent&);
+	bool Test (DnnEvent& e);
+
+public:
+		DnnBasicCriterion ();
+		DnnBasicCriterion (bool  (*c) (DnnEvent&));
+		~DnnBasicCriterion ();
+inline	void	ChangeCriterion (bool (*c) (DnnEvent&))	{Check = c; }
+};
+
+template <class T> class DnnCriterionOf : public DnnBaseCriterion {
+protected:
+	T&	Object;
+	void	(T::*Check)	(DnnEvent&);
+
+public:
+		DnnCriterionOf (T& o, void (T::*c) (DnnEvent&)) : DnnBaseCriterion (), Object (o), Check (c)	{}
+		~DnnCriterionOf ()	{}
+	bool	Test (DnnEvent& ev)	{ return (Object.*Check) (ev); }
+};
+
+#define SpecializedCriterion(R,S) \
+\
+class R : public DnnBaseCriterion { \
+\
+protected: \
+\
+    S& Body; \
+    bool  (S::*SpecializedCheck) (DnnEvent&); \
+\
+public: \
+\
+    R (S& s, bool  (S::*sc) (DnnEvent&)) : DnnBaseCriterion (), Body (s), SpecializedCheck (sc) {} \
+   ~R () {} \
+\
+    bool  Test (DnnEvent& e) { return (Body.*SpecializedCheck) (e); } \
+\
+};
+
+#endif	/* DnnCriterion_H_ */
diff --git a/dnn/Disposable.cc b/dnn/Disposable.cc
new file mode 100755
index 0000000..4e8a03a
--- /dev/null
+++ b/dnn/Disposable.cc
@@ -0,0 +1,78 @@
+/*
+ *	DNN - Data News Network
+ *
+ *	by Stephane Chatty and Stephane Sire
+ *
+ *	Copyright 1993-1996
+ *	Centre d'Etudes de la Navigation Aerienne (CENA)
+ *
+ *	Disposable objects.
+ *
+ *	$Id$
+ *	$CurLog$
+ */
+
+#include "Disposable.h"
+#include "Loop.h"
+
+bool DnnDisposable::ClassInitialized = false;
+CcuInitializerFor<DnnBaseMultiplexer> DnnDisposable::Dependance;
+CcuInitializerFor<DnnDisposable> DnnDisposable::Initializer;
+CcuListOf<DnnDisposable> DnnDisposable::Garbage;
+
+void
+DnnDisposable :: ClassInit ()
+{
+	if (!ClassInitialized) {
+		ClassInitialized = true;
+		DnnBaseMultiplexer::AddGlobalHook (&DnnDisposable::DeleteGarbage, true);
+	}
+}
+
+#if 0
+void
+DnnDisposable :: ClassClose ()
+{
+	DnnBaseMultiplexer::RemoveGlobalHook (&DnnDisposable::DeleteGarbage);
+}
+#endif
+
+
+/*? 
+\typ{DnnDisposable} objects are objects whose deletion is called in a safe
+place  in an asynchronous way.
+Instances of derived class of DnnDisposable which are to be deleted
+asynchronously must be allocated only dynamically with new.
+
+An instance is put into it's class garbage list (and thus deleted)
+by calling \fun{AsynchronousDelete} on itself.
+A mechanism of Lock and Unlock is also provided to prevent 
+a deletion while in an unsafe state.
+
+Typically this class is to be used by derivation of UchChannel
+which can be deleted from within themselves after a call to \fun{HandleRead}.
+?*/
+DnnDisposable :: DnnDisposable () 
+{
+}
+
+DnnDisposable :: ~DnnDisposable ()
+{
+}
+
+void
+DnnDisposable :: Trash ()
+{ 
+	Garbage.Append (this); 
+};
+
+/*? 
+Delete all the instances which are in the garbage list.
+?*/
+void
+DnnDisposable :: DeleteGarbage ()
+{
+	DnnDisposable* d;
+	while (d = Garbage.RemoveFirst ())
+		delete d;
+}
diff --git a/dnn/Disposable.h b/dnn/Disposable.h
new file mode 100755
index 0000000..e6f10f7
--- /dev/null
+++ b/dnn/Disposable.h
@@ -0,0 +1,45 @@
+/*
+ *	DNN - Data News Network
+ *
+ *	by Stephane Chatty and Stephane Sire
+ *
+ *	Copyright 1993-1996
+ *	Centre d'Etudes de la Navigation Aerienne (CENA)
+ *
+ *	Disposable objects.
+ *
+ *	$Id$
+ *	$CurLog$
+ */
+
+#ifndef DnnDisposable_H_
+#define DnnDisposable_H_
+
+#include "ccu/List.h"
+#include "ccu/Initializer.h"
+#include "Loop.h"
+
+class DnnDisposable {
+
+public:
+static	bool	ClassInitialized;
+static	void	ClassInit ();
+static	CcuInitializerFor <DnnDisposable>	Initializer;
+
+protected:
+static	CcuListOf <DnnDisposable>	Garbage;
+
+private:
+static	CcuInitializerFor <DnnBaseMultiplexer>	Dependance;
+
+protected:
+		DnnDisposable ();
+
+public:
+virtual		~DnnDisposable ();
+    	void	Trash ();
+
+static 	void	DeleteGarbage ();
+};
+
+#endif	/* DnnDisposable_H_ */
diff --git a/dnn/Loop.cc b/dnn/Loop.cc
new file mode 100755
index 0000000..a655e8b
--- /dev/null
+++ b/dnn/Loop.cc
@@ -0,0 +1,165 @@
+/*
+ *	DNN - Data News Network
+ *
+ *	by Stephane Chatty and Stephane Sire
+ *
+ *	Copyright 1993-1996
+ *	Centre d'Etudes de la Navigation Aerienne (CENA)
+ *
+ *	Multiplexer
+ *
+ *	$Id$
+ *	$CurLog$
+ */
+
+#include "Loop.h"
+
+CcuInitializerFor<DnnBaseMultiplexer> DnnBaseMultiplexer::Initializer;
+bool DnnBaseMultiplexer::ClassInitialized = false;
+CcuList* DnnBaseMultiplexer::GlobalHooks = 0;
+CcuList* DnnBaseMultiplexer::GlobalFinalHooks = 0;
+DnnBaseMultiplexer* DnnMpx = 0;
+
+void
+DnnBaseMultiplexer :: ClassInit ()
+{
+	if (!ClassInitialized) {
+		ClassInitialized = true;
+		GlobalHooks = new CcuList;
+		GlobalFinalHooks = new CcuList;
+	}
+}
+
+void
+DnnBaseMultiplexer :: AddGlobalHook (DnnMpxHook* h, bool final)
+{
+	GlobalHooks->Append ((void*) h);
+	if (final)
+		GlobalFinalHooks->Append ((void*) h);
+}
+
+void
+DnnBaseMultiplexer :: RemoveGlobalHook (DnnMpxHook* h, bool final)
+{
+	GlobalHooks->Remove ((void*) h);
+	if (final)
+		GlobalFinalHooks->Remove ((void*) h);
+}
+
+
+DnnBaseMultiplexer :: DnnBaseMultiplexer ()
+{
+}
+
+DnnBaseMultiplexer :: ~DnnBaseMultiplexer ()
+{
+}
+
+/* useless? */
+MPX_RES
+DnnBaseMultiplexer :: Run ()
+{
+	return Loop ();
+}
+
+
+DnnMultiplexer :: DnnMultiplexer ()
+: DnnBaseMultiplexer (),
+  Hooks (),
+  FinalHooks ()
+{
+}
+
+DnnMultiplexer :: ~DnnMultiplexer ()
+{
+}
+
+void
+DnnMultiplexer :: AddHook (DnnMpxHook* h, bool final)
+{
+	Hooks.Append ((void*) h);
+	if (final)
+		FinalHooks.Append ((void*) h);
+}
+
+void
+DnnMultiplexer :: RemoveHook (DnnMpxHook* h, bool final)
+{
+	Hooks.Remove ((void*) h);
+	if (final)
+		FinalHooks.Remove ((void*) h);
+}
+
+void
+DnnMultiplexer :: AddFinalHook (DnnMpxHook* h)
+{
+	FinalHooks.Append ((void*) h);
+}
+
+void
+DnnMultiplexer :: RemoveFinalHook (DnnMpxHook* h)
+{
+	FinalHooks.Remove ((void*) h);
+}
+
+
+void
+DnnMultiplexer :: ExecHooks (bool final)
+{
+	CcuList* hooks = final ? &FinalHooks : &Hooks;
+	CcuListIter li = *hooks;
+	while (++li) {
+		DnnMpxHook* h = (DnnMpxHook*) *li;
+		(*h)();
+	}
+}
+
+MPX_RES
+DnnMultiplexer :: Loop ()
+{
+	Looping = true;
+	while (Looping)
+		ExecHooks (false);
+	ExecHooks (true);
+	return isMpxTerminated;
+}
+
+void
+DnnMultiplexer :: Stop ()
+{
+	Looping = false;
+}
+
+
+void
+DnnOpen (DnnBaseMultiplexer* m)
+{
+	DnnMpx = m ? m : new DnnMultiplexer;
+
+	CcuListIter li = *DnnBaseMultiplexer::GlobalHooks;
+	while (++li)
+		DnnMpx->AddHook ((DnnMpxHook*) *li, false);
+
+	li = *DnnBaseMultiplexer::GlobalFinalHooks;
+	while (++li)
+		DnnMpx->AddFinalHook ((DnnMpxHook*) *li);
+}
+
+MPX_RES
+DnnLoop ()
+{
+	return DnnMpx->Loop ();
+}
+
+void
+DnnStop ()
+{
+	DnnMpx->Stop ();
+}
+
+void
+DnnClose ()
+{
+}
+
+
diff --git a/dnn/Loop.h b/dnn/Loop.h
new file mode 100644
index 0000000..9009c39
--- /dev/null
+++ b/dnn/Loop.h
@@ -0,0 +1,82 @@
+/*
+ *	DNN - Data News Network
+ *
+ *	by Stephane Chatty and Stephane Sire
+ *
+ *	Copyright 1993-1996
+ *	Centre d'Etudes de la Navigation Aerienne (CENA)
+ *
+ *	Multiplexer.
+ *
+ *	$Id$
+ *	$CurLog$
+ */
+
+#ifndef DnnMultiplexer_H_
+#define DnnMultiplexer_H_
+
+#include "ccu/Initializer.h"
+#include "ccu/List.h"
+
+enum MPX_RES { isMpxEmpty, isMpxTerminated, isMpxError, isMpxAborted };
+
+typedef void (DnnMpxHook) ();
+
+class DnnBaseMultiplexer {
+friend	void	DnnOpen (DnnBaseMultiplexer*);
+friend	MPX_RES	DnnLoop ();
+friend	void	DnnClose ();
+
+public:
+static	bool	ClassInitialized;
+static	void	ClassInit ();
+static	CcuInitializerFor <DnnBaseMultiplexer>	Initializer;
+
+protected:
+static	CcuList*	GlobalHooks;
+static	CcuList*	GlobalFinalHooks;
+virtual	MPX_RES	Loop () = 0;
+
+public:
+		DnnBaseMultiplexer ();
+virtual		~DnnBaseMultiplexer ();
+
+	MPX_RES	Run ();
+virtual	void	Stop () = 0;
+
+static	void	AddGlobalHook (DnnMpxHook*, bool = false);
+static	void	RemoveGlobalHook (DnnMpxHook*, bool = false);
+virtual	void	AddHook (DnnMpxHook*, bool = false) = 0;
+virtual	void	RemoveHook (DnnMpxHook*, bool = false) = 0;
+virtual	void	AddFinalHook (DnnMpxHook*) = 0;
+virtual	void	RemoveFinalHook (DnnMpxHook*) = 0;
+};
+
+class DnnMultiplexer : public DnnBaseMultiplexer {
+protected:
+	CcuList	Hooks;
+	CcuList	FinalHooks;
+	bool	Looping;
+
+	void	ExecHooks (bool = false);
+	MPX_RES	Loop ();
+
+public:
+		DnnMultiplexer ();
+		~DnnMultiplexer ();
+	void	Stop ();
+	void	AddHook (DnnMpxHook*, bool = false);
+	void	RemoveHook (DnnMpxHook*, bool = false);
+	void	AddFinalHook (DnnMpxHook*);
+	void	RemoveFinalHook (DnnMpxHook*);
+};
+
+
+extern DnnBaseMultiplexer* DnnMpx;
+extern void DnnOpen (DnnBaseMultiplexer* = 0);
+extern MPX_RES DnnLoop ();
+extern void DnnStop ();
+extern void DnnClose ();
+
+
+#endif	/* DnnMultiplexer_H_ */
diff --git a/dnn/Source.cc b/dnn/Source.cc
new file mode 100755
index 0000000..516a710
--- /dev/null
+++ b/dnn/Source.cc
@@ -0,0 +1,171 @@
+/*
+ *	DNN - Data News Network
+ *
+ *	by Stephane Chatty
+ *
+ *	Copyright 1993-1996
+ *	Centre d'Etudes de la Navigation Aerienne (CENA)
+ *
+ *	Event sources.
+ *
+ *	$Id$
+ *	$CurLog$
+ */
+
+#include "Source.h"
+#include "Trigger.h"
+#include "Reaction.h"
+#include "ccu/Array.h"
+#include "ccu/HashTable.h"
+
+DnnEventSource :: DnnEventSource ()
+{
+}
+
+DnnEventSource :: ~DnnEventSource ()
+{
+}
+
+void
+DnnEventSource :: Emit (DnnEvent* ev)
+{
+	/* should enqueue? */
+	DispatchEvent (ev);
+}
+
+DnnEventSelector :: DnnEventSelector ()
+{
+}
+
+DnnEventSelector :: ~DnnEventSelector ()
+{
+}
+
+DnnEventIntSelector :: DnnEventIntSelector (DnnIntExtractor exid, int max)
+: DnnEventSelector (),
+  IdExtractor (exid),
+  MaxSize (max),
+  Triggers (0)
+{
+}
+
+DnnEventIntSelector :: ~DnnEventIntSelector ()
+{
+	if (Triggers) {
+		int id = 0;
+#ifdef FIXME
+		while (id < MaxSize) {
+			DnnTrigger* t = (*Triggers)[id];
+			if (t)
+				delete t;
+		}
+#endif
+	}
+}
+
+DnnTrigger*
+DnnEventIntSelector :: UseTrigger (int id)
+{
+	if (!Triggers && MaxSize) {
+		Triggers = new CcuArrayOf<DnnTrigger> (MaxSize, 0);
+	}
+
+	/* no need to check bounds: CcuArray does it */
+	DnnTrigger** t = *Triggers + id;
+	if (*t == 0) {
+		*t = new DnnTrigger;
+	}
+
+	return *t;
+}
+
+
+void
+DnnEventIntSelector :: UnuseTrigger (int id, DnnBaseReaction* r)
+{
+	DnnTrigger** t;
+	if (!Triggers || !(t = *Triggers + id))
+		return;
+
+	r->UnsubscribeTo (**t);
+	if ((*t)->IsUnused ()) {
+		delete *t;
+		*t = 0;
+	}
+}
+
+DnnTrigger*
+DnnEventIntSelector :: FindTrigger (DnnEvent* ev)
+{
+	DnnTrigger* t = 0;
+	int id = (IdExtractor) (ev);
+	if (Triggers)
+		t = (*Triggers) [id];
+	return t;
+}
+
+
+DnnEventPtrSelector :: DnnEventPtrSelector (DnnPtrExtractor exid, int sz)
+: DnnEventSelector (),
+  PtrExtractor (exid),
+  TblSize (sz),
+  Triggers (0)
+{
+}
+
+DnnEventPtrSelector :: ~DnnEventPtrSelector ()
+{
+	if (Triggers) {
+		int id = 0;
+#ifdef FIXME
+#endif
+	}
+}
+
+DnnTrigger*
+DnnEventPtrSelector :: UseTrigger (void* id)
+{
+	if (!Triggers && TblSize) {
+		Triggers = new CcuHashTableOf<DnnTrigger> (TblSize);
+	}
+
+	int found;
+	CcuHashCellOf<DnnTrigger>* c = Triggers->Add (id, &found);
+	DnnTrigger* t;
+	if (found)
+		t = c->GetInfo ();
+	else
+		c->SetInfo (t = new DnnTrigger);
+	return t;
+}
+
+
+void
+DnnEventPtrSelector :: UnuseTrigger (void* id, DnnBaseReaction* r)
+{
+	CcuHashCellOf<DnnTrigger>* c;
+	if (!Triggers || !(c = Triggers->Get (id)))
+		return;
+
+	DnnTrigger* t = c->GetInfo ();
+	r->UnsubscribeTo (*t);
+	if (t->IsUnused ()) {
+		delete t;
+		/* not optimal : we already had the cell */
+		Triggers->Remove (id);
+	}
+}
+
+DnnTrigger*
+DnnEventPtrSelector :: FindTrigger (DnnEvent* ev)
+{
+	DnnTrigger* t = 0;
+	CcuHashCellOf<DnnTrigger>* c;
+
+	void* id = (PtrExtractor) (ev);
+
+	if (Triggers && (c = Triggers->Get (id)))
+		t = c->GetInfo ();
+	return t;
+}
+
diff --git a/dnn/Source.h b/dnn/Source.h
new file mode 100755
index 0000000..ab5d55c
--- /dev/null
+++ b/dnn/Source.h
@@ -0,0 +1,72 @@
+/*
+ *	DNN - Data News Network
+ *
+ *	by Stephane Chatty
+ *
+ *	Copyright 1993-1996
+ *	Centre d'Etudes de la Navigation Aerienne (CENA)
+ *
+ *	Event sources.
+ *
+ *	$Id$
+ *	$CurLog$
+ */
+
+#ifndef DnnSource_H_
+#define DnnSource_H_
+
+#include "cplus_bugs.h"
+template <class ITEM> class CcuArrayOf;
+template <class ITEM> class CcuHashTableOf;
+class DnnTrigger;
+class DnnEvent;
+class DnnBaseReaction;
+
+
+class DnnEventSource {
+protected:
+		DnnEventSource ();
+virtual		~DnnEventSource ();
+	void	Emit (DnnEvent*);
+virtual	void	DispatchEvent (DnnEvent*) = 0;
+};
+
+class DnnEventSelector {
+public:
+		DnnEventSelector ();
+virtual		~DnnEventSelector ();
+virtual	DnnTrigger*	FindTrigger (DnnEvent*) = 0;
+};
+
+typedef int (*DnnIntExtractor) (DnnEvent*);
+
+class DnnEventIntSelector : public DnnEventSelector {
+protected:
+	DnnIntExtractor	IdExtractor;
+	int	MaxSize;
+	CcuArrayOf<DnnTrigger>	*Triggers;
+public:
+		DnnEventIntSelector (DnnIntExtractor, int);
+		~DnnEventIntSelector ();
+	DnnTrigger*	UseTrigger (int);
+	void	UnuseTrigger (int, DnnBaseReaction*);
+	DnnTrigger*	FindTrigger (DnnEvent*);
+};
+
+typedef void* (*DnnPtrExtractor) (DnnEvent*);
+
+class DnnEventPtrSelector : public DnnEventSelector {
+protected:
+	DnnPtrExtractor	PtrExtractor;
+	int	TblSize;
+	CcuHashTableOf<DnnTrigger>	*Triggers;
+public:
+		DnnEventPtrSelector (DnnPtrExtractor, int);
+		~DnnEventPtrSelector ();
+	DnnTrigger*	UseTrigger (void*);
+	void	UnuseTrigger (void*, DnnBaseReaction*);
+	DnnTrigger*	FindTrigger (DnnEvent*);
+};
+
+
+#endif	/* DnnSource_H_ */