Integration into IvyLeague

Uvh -> Ivl
Multiplexer.* is renamed into Scheduler.*
A few name conflicts in the merger with ex-DNN have been solved
Imakefile is replaced by Makefile
Created InetAddress.* and UnixAddress.* from Address.*
Created IrdaAddress.*
OLD/TextStream has been updated

1 files changed, 21 insertions, 21 deletions

diff --git a/comm/SignalHandler.cc b/comm/SignalHandler.cc
index 2bf3bba..86db5fe 100644
--- a/comm/SignalHandler.cc
+++ b/comm/SignalHandler.cc
@@ -7,7 +7,7 @@
  *	Laboratoire de Recherche en Informatique (LRI)
  *	Centre d'Etudes de la Navigation Aerienne
  *
- *	Multiplexer-based signal handlers
+ *	Scheduler-based signal handlers
  *
  *	$Id$
  *	$CurLog$
@@ -17,30 +17,30 @@
 #pragma implementation "SignalHandler.h"
 #endif
 #include "SignalHandler.h"
-#include "Multiplexer.h"
+#include "Scheduler.h"
 
-/*?class UchBaseSignalHandler
-The class \typ{UchBaseSignalHandler} is provided as a base class for safe signal handlers,
+/*?class IvlBaseScheduledHandler
+The class \typ{IvlBaseScheduledHandler} is provided as a base class for safe signal handlers,
 ie. signal handlers that are activated only when no data is being transferred on a channel.
-It is a derived class of \typ{CcuBaseSignalHandler}, in which the method \fun{Handle} is
+It is a derived class of \typ{IvlBaseScheduledHandler}, in which the method \fun{Handle} is
 defined to hold the signal until safe times. The virtual function \fun{DeferredHandle},
 that should be redefined in derived classes, is called later.
-The class \typ{UchBaseSignalHandler} comes with a derived class
-\typ{CcuSignalHandler} that can be used as is, without any derivation.
+The class \typ{IvlBaseScheduledHandler} comes with a derived class
+\typ{IvlScheduledHandler} that can be used as is, without any derivation.
 ?*/
 
 /*?
 Create a signal handler associated to the multiplexer \var{m},
 for the signal \var{sig}.
 ?*/
-UchBaseSignalHandler :: UchBaseSignalHandler (UchBaseMultiplexer& m, int sig)
-: CcuBaseSignalHandler (sig),
-  MyMpx (m)
+IvlBaseScheduledHandler :: IvlBaseScheduledHandler (IvlBaseScheduler& m, int sig)
+: IvlBaseSignalHandler (sig),
+  MyScd (m)
 {
 }
 
 /*?nodoc?*/
-UchBaseSignalHandler :: ~UchBaseSignalHandler ()
+IvlBaseScheduledHandler :: ~IvlBaseScheduledHandler ()
 {
 }
 
@@ -49,9 +49,9 @@ Ask the multiplexer to hold the signal and call us when it is safe.
 !*/
 /*?hidden?*/
 void
-UchBaseSignalHandler :: Handle ()
+IvlBaseScheduledHandler :: Handle ()
 {
-	MyMpx.HandleSignal (*this);
+	MyScd.HandleSignal (*this);
 }
 
 /*?
@@ -63,14 +63,14 @@ that were received. This function is not called during an
 interruption, and does not suffer any constraint.
 ?*/
 void
-UchBaseSignalHandler :: DeferredHandle (int nb)
+IvlBaseScheduledHandler :: DeferredHandle (int nb)
 {
 }
 
-/*?class UchSignalHandler
-The class \typ{UchSignalHandler} is a derived class of \typ{UchBaseSignalHandler} that
+/*?class IvlScheduledHandler
+The class \typ{IvlScheduledHandler} is a derived class of \typ{IvlBaseScheduledHandler} that
 can be used without deriving a new class.
-Each \typ{UchSignalHandler} holds a pointer to a function which is called when a
+Each \typ{IvlScheduledHandler} holds a pointer to a function which is called when a
 signal is received. This function, which is passed to the constructor, must
 take an \typ{int} argument and return \typ{void}.
 ?*/
@@ -80,20 +80,20 @@ Create a signal handler for signal \var{sig}. The function \var{h} will be
 called when a signal has to be handled. Its two arguments are the identification
 of the signal, and the number of signals that were received.
 ?*/
-UchSignalHandler :: UchSignalHandler (UchBaseMultiplexer& m, int sig, void (*h) (int, int))
-: UchBaseSignalHandler (m, sig),
+IvlScheduledHandler :: IvlScheduledHandler (IvlBaseScheduler& m, int sig, void (*h) (int, int))
+: IvlBaseScheduledHandler (m, sig),
   Handler (h)
 {
 }
 
 /*?nodoc?*/
-UchSignalHandler :: ~UchSignalHandler ()
+IvlScheduledHandler :: ~IvlScheduledHandler ()
 {
 }
 
 /*?hidden?*/
 void
-UchSignalHandler :: DeferredHandle (int nb)
+IvlScheduledHandler :: DeferredHandle (int nb)
 {
 	(*Handler) (Signal, nb);
 }