From bcb19dbd53973ff7efd9b2838de121d1e23430f4 Mon Sep 17 00:00:00 2001 From: chatty Date: Tue, 28 Nov 2000 14:52:15 +0000 Subject: Lots of files were added around '96 --- dnn/Behaviour.cc | 151 +++++++++++++++++++++++++++++++++++++++++++++++ dnn/Behaviour.h | 104 +++++++++++++++++++++++++++++++++ dnn/Criterion.cc | 142 +++++++++++++++++++++++++++++++++++++++++++++ dnn/Criterion.h | 103 ++++++++++++++++++++++++++++++++ dnn/Disposable.cc | 78 +++++++++++++++++++++++++ dnn/Disposable.h | 45 ++++++++++++++ dnn/Loop.cc | 165 ++++++++++++++++++++++++++++++++++++++++++++++++++++ dnn/Loop.h | 82 ++++++++++++++++++++++++++ dnn/Source.cc | 171 ++++++++++++++++++++++++++++++++++++++++++++++++++++++ dnn/Source.h | 72 +++++++++++++++++++++++ 10 files changed, 1113 insertions(+) create mode 100755 dnn/Behaviour.cc create mode 100755 dnn/Behaviour.h create mode 100755 dnn/Criterion.cc create mode 100755 dnn/Criterion.h create mode 100755 dnn/Disposable.cc create mode 100755 dnn/Disposable.h create mode 100755 dnn/Loop.cc create mode 100644 dnn/Loop.h create mode 100755 dnn/Source.cc create mode 100755 dnn/Source.h (limited to 'dnn') 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 +#include + +DnnToken :: DnnToken () +{ +} + +DnnToken :: ~DnnToken () +{ +} + +DnnState :: DnnState (const char* name) +: Name (name), + Transitions () +{ +} + +DnnState :: ~DnnState () +{ + CcuListIterOf 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 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 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 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 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 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 li = b.Conditions; + while (++li) + Conditions.Append (*li); + return *this; +} + +bool +DnnAndCriterion :: Test (DnnEvent& ev) +{ + bool res = true; + CcuListIterOf 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 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 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 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 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 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 DnnDisposable::Dependance; +CcuInitializerFor DnnDisposable::Initializer; +CcuListOf 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 Initializer; + +protected: +static CcuListOf Garbage; + +private: +static CcuInitializerFor 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::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 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 (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 (TblSize); + } + + int found; + CcuHashCellOf* 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* 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* 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 CcuArrayOf; +template 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 *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 *Triggers; +public: + DnnEventPtrSelector (DnnPtrExtractor, int); + ~DnnEventPtrSelector (); + DnnTrigger* UseTrigger (void*); + void UnuseTrigger (void*, DnnBaseReaction*); + DnnTrigger* FindTrigger (DnnEvent*); +}; + + +#endif /* DnnSource_H_ */ -- cgit v1.1