Initial revision

1 files changed, 193 insertions, 0 deletions

diff --git a/utils/metaclass.cc b/utils/metaclass.cc
new file mode 100644
index 0000000..c07755c
--- /dev/null
+++ b/utils/metaclass.cc
@@ -0,0 +1,193 @@
+/*
+ *	CENA C++ Utilities
+ *
+ *	by Stephane Chatty
+ *
+ *	Copyright 1991, 1992
+ *	Laboratoire de Recherche en Informatique (LRI)
+ *	Centre d'Etudes de la Navigation Aerienne (CENA)
+ *
+ *	metaclasses, originally by Michel Beaudouin-Lafon
+ *
+ *	$Id$
+ *	$CurLog$
+ */
+
+
+#include "MetaClass.h"
+#include <string.h>
+
+/*?class MetaClass
+This class provides minimal support for metaclasses in C++.
+A \typ{MetaClass} object represents a C++ class.
+It contains a name (a string holding the name of the C++ class), and the inheritance information.
+Multiple inheritance is not supported in this version.
+?*/
+
+/*
+a discuter :
+	autres fonctions dans MetaClass, notamment pour le transport d'objet
+		stocker dans l'objet MetaClass la fonction de chargement/ecriture
+		mettre les MetaClass dans une h-table indexee par le nom
+	persistance: la description des classes pour la sauvegarde/chargement pourrait etre
+	non pas dans le code, mais dans un fichier (par exemple le .h !!!)
+	faut-il conserver la liste des classes filles ?
+ */
+
+
+/*?
+Create a metaclass for the base class named \var{n}.
+?*/
+MetaClass :: MetaClass (const char* n)
+: Name (n),
+  BaseClasses ()
+{
+}
+
+/*?
+Create a metaclass for the derived class named \var{n}.
+\var{s} is the metaclass of the base class of the class named \var{n}.
+?*/
+MetaClass :: MetaClass (const char* n, MetaClass& s)
+: Name (n),
+  BaseClasses ()
+{
+	BaseClasses->Append (s);
+}
+
+/*?
+Return true if this metaclass is a derived class of the metaclass s.
+?*/
+int
+MetaClass :: IsDerivedClass (const MetaClass& s) const
+{
+	register const MetaClass* m = this;
+	do {
+		if (m == &s)
+			return 1;
+	} while (m = m->BaseClass);
+	return 0;
+}
+
+/*?
+Return 1 if this metaclass is a derived class of the metaclass named \var{n}.
+This form is less efficient than the previous one.
+It may be useful to avoid including the definition of the class named \var{n}.
+?*/
+int
+MetaClass :: IsSubClass (const char* n) const
+{
+	register const MetaClass* m = this;
+	do {
+		if (strcmp (m->name, n) == 0)
+			return 1;
+	} while (m = m->BaseClass);
+	return 0;
+}
+
+#ifdef DOC
+// fake entries for documentation
+
+/*?
+Return the superClass of this metaclass.
+Note that base classe have MetaClass::ROOT as superClass.
+MetaClass::ROOT is its own metaclass
+(there is a loop at the root of the inheritance tree).
+?*/
+MetaClass&
+MetaClass :: SuperClass () const
+{
+}
+
+/*?
+Return the name of this metaclass.
+By convention, it is identical to the identifier for the class represented by this metaclass.
+?*/
+const char*	
+MetaClass :: Name () const
+{
+}
+
+/*?
+This conversion operator returns the name of this metaclass.
+See the member function Name.
+?*/
+MetaClass :: operator const char* () const
+{
+}
+
+/*?nextdoc?*/
+int	
+MetaClass :: Base () const
+{
+}
+
+/*?
+Return true if the class represented by this metaclass
+is a base class (resp. a derived class).
+?*/
+int	
+MetaClass :: Derived () const
+{
+}
+
+/*?
+Return 0 if this metaclass is MetaClass::ROOT, else return 1.
+This makes it easy to walk up the hierarchy of metaclasses:\\
+\hspace*{1cm}\com{while (mc = mc.SuperClass ()) ...}.
+?*/
+MetaClass :: operator int () const
+{
+}
+
+
+/*?nextdoc?*/
+int	
+MetaClass :: operator <= (const MetaClass& c) const
+{
+}
+
+/*?nextdoc?*/
+int	
+MetaClass :: operator >= (const MetaClass& c) const
+{
+}
+
+/*?nextdoc?*/
+int	
+MetaClass :: operator < (const MetaClass& c) const
+{
+}
+
+/*?nextdoc?*/
+int	
+MetaClass :: operator > (const MetaClass& c) const
+{
+}
+/*?nextdoc?*/
+int	
+MetaClass :: operator == (const MetaClass& c) const
+{
+}
+/*?
+Relational operations between metaclasses.
+The metaclass of class A is $<$ to the metaclass of class B
+if A is a derived class of B.
+The definitions of the other operators derive from this one.
+Note however that the order between metaclasses is not total :
+two metaclasses A and B can be uncomparable, that is
+neither A $<$ B or B $<$ A is true.
+This is the case when A does not derive from B and B does not derive from A.
+?*/
+int	
+MetaClass :: operator != (const MetaClass& c) const
+{
+}
+
+/*?nodoc?*/
+const MetaClass&
+MetaClass :: 	operator = (const MetaClass&)
+{
+}
+
+#endif