doc updated for code_gen

12 files changed, 203 insertions, 205 deletions

diff --git a/omegalib/omega/include/basic/Bag.h b/omegalib/omega/include/basic/Bag.h
index 42285d0..3bd7143 100644
--- a/omegalib/omega/include/basic/Bag.h
+++ b/omegalib/omega/include/basic/Bag.h
@@ -14,13 +14,14 @@ virtual ~Bag();
 	Bag();
 	Bag(const Bag<T>&);
 	Bag & operator=(const Bag<T>&);
-virtual	void operator |= (const Bag<T> & b); // add elements in b
+    //! add elements in b
+    virtual	void operator |= (const Bag<T> & b);
 	Iterator<T> *new_iterator();
 	bool empty() const;
 	void remove(T);
-virtual	void insert(T);
+    virtual	void insert(T);
 	void clear();
-virtual	bool contains(T) const;
+    virtual	bool contains(T) const;
 	int size() const;
 	T extract();
 // protected:  breaks g++ 261
@@ -31,10 +32,11 @@ virtual	bool contains(T) const;
 template<class T> class Ordered_Bag : public Bag<T> { 
 public:
 	Ordered_Bag();
-// virtual ~Ordered_Bag();
 	Ordered_Bag(const Ordered_Bag<T>& B) : Bag<T>(B) {}
 	void insert(T);
-virtual	void operator |= (const Ordered_Bag<T> & b); // add elements in b
+    //! add elements in b
+    virtual	void operator |= (const Ordered_Bag<T> & b);
+    //! add elements in b
 	void operator |= (const Bag<T> & b);
 	bool  contains(T) const;
         bool  operator == (const Ordered_Bag<T>&) const;
@@ -45,21 +47,26 @@ virtual	void operator |= (const Ordered_Bag<T> & b); // add elements in b
 template <class T> class Set : public Ordered_Bag <T> { 
 public:
 	Set();
-// virtual ~Set();
 	Set(T);
 	Set(const Set<T>& S) : Ordered_Bag<T>(S) {}
 
         bool  contains (const Set<T>& b) const;
         bool  contains (T t) const { return Ordered_Bag<T>::contains(t); }
 	// the above makes "standard" C++ happy
-
-virtual	void operator |= (const Set<T> & b); // add elements in b
+    
+    //! add elements in b
+    virtual	void operator |= (const Set<T> & b);
+    //! add elements in b
 	void operator |= (const Ordered_Bag<T> & b);
+    //! add elements in b
 	void operator |= (const Bag<T> & b);
 
-        void operator -= (const Set<T> & b); // delete items also in b
-        void operator &= (const Set<T> & b); // delete items not in b
-        bool operator & (const Set<T> &) const; // check for elements in common
+    //! delete items also in b
+    void operator -= (const Set<T> & b);
+    //! delete items not in b
+    void operator &= (const Set<T> & b);
+    //! check for elements in common
+    bool operator & (const Set<T> &) const;
 };
 
 } // namespace
diff --git a/omegalib/omega/include/basic/BoolSet.h b/omegalib/omega/include/basic/BoolSet.h
index dc9ef83..a78af2e 100755
--- a/omegalib/omega/include/basic/BoolSet.h
+++ b/omegalib/omega/include/basic/BoolSet.h
@@ -25,7 +25,8 @@
 #include <iterator>
 
 namespace omega {
-  
+
+    //!  BoolSet class, used as a set of integers from 0 to n-1 where n is a very small integer.
 template<typename T = unsigned int>
 class BoolSet {
 protected:
@@ -50,17 +51,20 @@ public:
   BoolSet<T> &operator|=(const BoolSet<T> &); 
   BoolSet<T> &operator&=(const BoolSet<T> &); 
   BoolSet<T> &operator-=(const BoolSet<T> &); 
-  
-  template<typename TT> friend BoolSet<TT> operator|(const BoolSet<TT> &, const BoolSet<TT> &);  // union
-  template<typename TT> friend BoolSet<TT> operator&(const BoolSet<TT> &, const BoolSet<TT> &);  // intersection
-  template<typename TT> friend BoolSet<TT> operator-(const BoolSet<TT> &, const BoolSet<TT> &);  // difference  
-  template<typename TT> friend BoolSet<TT> operator~(const BoolSet<TT> &);                       // complement
+
+  //! union
+  template<typename TT> friend BoolSet<TT> operator|(const BoolSet<TT> &, const BoolSet<TT> &);
+  //! intersection
+  template<typename TT> friend BoolSet<TT> operator&(const BoolSet<TT> &, const BoolSet<TT> &);
+  //! difference
+  template<typename TT> friend BoolSet<TT> operator-(const BoolSet<TT> &, const BoolSet<TT> &);
+  //! complement
+  template<typename TT> friend BoolSet<TT> operator~(const BoolSet<TT> &);                 
   template<typename TT> friend bool operator==(const BoolSet<TT> &, const BoolSet<TT> &); 
   template<typename TT> friend bool operator!=(const BoolSet<TT> &, const BoolSet<TT> &); 
   template<typename TT> friend std::ostream& operator<<(std::ostream &, const BoolSet<TT> &);
   template<typename TT> friend bool operator<(const BoolSet<TT> &, const BoolSet<TT> &);
 
-// iterator related
 public:
   class iterator;
   class const_iterator;
diff --git a/omegalib/omega/include/basic/Collection.h b/omegalib/omega/include/basic/Collection.h
index c7e4eef..80ddf48 100644
--- a/omegalib/omega/include/basic/Collection.h
+++ b/omegalib/omega/include/basic/Collection.h
@@ -7,10 +7,7 @@ template<class T> class Iterator;
 template<class T> class Any_Iterator;
 
 
-/*
- * protocol for any kind of collection
- */
-
+//! protocol for any kind of collection
 template<class T> class Collection {
 public:
     virtual Iterator<T> *new_iterator() = 0;
@@ -20,21 +17,20 @@ public:
 };
 
 
-/*
+/*!
  * protocol for collections whose elements are ordered
  * by the way they are entered into the collection, and
  * whose elements can be accessed by "index"
  *
  * note that the implementation need not be a linked list
  */
-
 template<class T> class Sequence : public Collection<T> {
 public:
     virtual const T &operator[](int) const = 0;
     virtual       T &operator[](int)       = 0;
 
-    virtual int index(const T &) const = 0;  // Y in X --> X[X.index(Y)] == Y
-};
+    /*! Y in X --> X[X.index(Y)] == Y */
+    virtual int index(const T &) const = 0;  };
 
 } // namespace
 
diff --git a/omegalib/omega/include/basic/ConstString.h b/omegalib/omega/include/basic/ConstString.h
index 5149e55..f149c9d 100644
--- a/omegalib/omega/include/basic/ConstString.h
+++ b/omegalib/omega/include/basic/ConstString.h
@@ -10,7 +10,6 @@ namespace omega {
 // global, but if it and its size are static to Const_String,
 // the compiler still doesn't seem to like the definition,
 // or the declaration either for that matter.
-
 class ConstStringRep {
 public:
   const char *name;
diff --git a/omegalib/omega/include/basic/Dynamic_Array.c b/omegalib/omega/include/basic/DynamicArray.c
index 0300fd8..8ede2f7 100644
--- a/omegalib/omega/include/basic/Dynamic_Array.c
+++ b/omegalib/omega/include/basic/DynamicArray.c
@@ -1,9 +1,9 @@
 #include <assert.h>
-#include <basic/Dynamic_Array.h>
+#include <basic/DynamicArray.h>
 
 namespace omega {
   
-template<class T, int d> void Dynamic_Array<T,d>::do_constr()
+template<class T, int d> void DynamicArray<T,d>::do_constr()
     {
 // #if ! defined SHUT_UP_ABOUT_STATEMENT_WITH_NO_EFFECT_IN_DYNAMIC_ARRAY_CREATION
 //     assert(d > 0);
@@ -14,7 +14,7 @@ template<class T, int d> void Dynamic_Array<T,d>::do_constr()
     }
 
 
-template<class T> void Dynamic_Array1<T>::do_construct(int d0)
+template<class T> void DynamicArray1<T>::do_construct(int d0)
     {
     this->bounds = new int[1];
     this->bounds[0] = d0;
@@ -22,7 +22,7 @@ template<class T> void Dynamic_Array1<T>::do_construct(int d0)
     this->partial = false;
     }
 
-template<class T> void Dynamic_Array2<T>::do_construct(int d0, int d1)
+template<class T> void DynamicArray2<T>::do_construct(int d0, int d1)
     {
     this->bounds = new int[2];
     this->bounds[0] = d0;
@@ -31,7 +31,7 @@ template<class T> void Dynamic_Array2<T>::do_construct(int d0, int d1)
     this->partial = false;
     }
 
-template<class T> void Dynamic_Array3<T>::do_construct(int d0,int d1,int d2)
+template<class T> void DynamicArray3<T>::do_construct(int d0,int d1,int d2)
     {
     this->bounds = new int[3];
     this->bounds[0] = d0;
@@ -41,7 +41,7 @@ template<class T> void Dynamic_Array3<T>::do_construct(int d0,int d1,int d2)
     this->partial = false;
     }
 
-template<class T> void Dynamic_Array4<T>::do_construct(int d0,int d1,int d2,int d3)
+template<class T> void DynamicArray4<T>::do_construct(int d0,int d1,int d2,int d3)
     {
     this->bounds = new int[4];
     this->bounds[0] = d0;
@@ -52,53 +52,53 @@ template<class T> void Dynamic_Array4<T>::do_construct(int d0,int d1,int d2,int
     this->partial = false;
     }
 
-template<class T, int d> Dynamic_Array<T,d>::Dynamic_Array()
+template<class T, int d> DynamicArray<T,d>::DynamicArray()
     {
     do_constr();
     }
 
-template<class T> Dynamic_Array1<T>::Dynamic_Array1(const char *)
+template<class T> DynamicArray1<T>::DynamicArray1(const char *)
     {
     this->do_constr();
     }
 
-template<class T> Dynamic_Array2<T>::Dynamic_Array2(const char *,const char *)
+template<class T> DynamicArray2<T>::DynamicArray2(const char *,const char *)
     {
     this->do_constr();
     }
 
-template<class T> Dynamic_Array3<T>::Dynamic_Array3(const char *,const char *,const char *)
+template<class T> DynamicArray3<T>::DynamicArray3(const char *,const char *,const char *)
     {
     this->do_constr();
     }
 
-template<class T> Dynamic_Array4<T>::Dynamic_Array4(const char *,const char *,const char *,const char *)
+template<class T> DynamicArray4<T>::DynamicArray4(const char *,const char *,const char *,const char *)
     {
     this->do_constr();
     }
 
-template<class T> Dynamic_Array1<T>::Dynamic_Array1(int d0)
+template<class T> DynamicArray1<T>::DynamicArray1(int d0)
     {
     do_construct(d0);
     } 
 
-template<class T> Dynamic_Array2<T>::Dynamic_Array2(int d0, int d1)
+template<class T> DynamicArray2<T>::DynamicArray2(int d0, int d1)
     {
     do_construct(d0, d1);
     }
 
-template<class T> Dynamic_Array3<T>::Dynamic_Array3(int d0,int d1,int d2)
+template<class T> DynamicArray3<T>::DynamicArray3(int d0,int d1,int d2)
     {
     do_construct(d0, d1, d2);
     }
 
-template<class T> Dynamic_Array4<T>::Dynamic_Array4(int d0,int d1,int d2,int d3)
+template<class T> DynamicArray4<T>::DynamicArray4(int d0,int d1,int d2,int d3)
     {
     do_construct(d0, d1, d2, d3);
     }
 
 
-template<class T, int d> void Dynamic_Array<T,d>::do_destruct()
+template<class T, int d> void DynamicArray<T,d>::do_destruct()
     {
     if (! partial)
 	{
@@ -108,13 +108,13 @@ template<class T, int d> void Dynamic_Array<T,d>::do_destruct()
     }
 
 
-template<class T, int d> Dynamic_Array<T,d>::~Dynamic_Array()
+template<class T, int d> DynamicArray<T,d>::~DynamicArray()
     {
     do_destruct();
     }
 
 
-template<class T> void Dynamic_Array1<T>::resize(int d0)
+template<class T> void DynamicArray1<T>::resize(int d0)
     {
     assert(!this->partial);
     this->do_destruct();
@@ -124,7 +124,7 @@ template<class T> void Dynamic_Array1<T>::resize(int d0)
         do_construct(d0);
     } 
 
-template<class T> void Dynamic_Array2<T>::resize(int d0, int d1)
+template<class T> void DynamicArray2<T>::resize(int d0, int d1)
     {
     assert(!this->partial);
     this->do_destruct();
@@ -134,7 +134,7 @@ template<class T> void Dynamic_Array2<T>::resize(int d0, int d1)
         do_construct(d0, d1);
     }
 
-template<class T> void Dynamic_Array3<T>::resize(int d0, int d1, int d2)
+template<class T> void DynamicArray3<T>::resize(int d0, int d1, int d2)
     {
     assert(!this->partial);
     this->do_destruct();
@@ -144,7 +144,7 @@ template<class T> void Dynamic_Array3<T>::resize(int d0, int d1, int d2)
         do_construct(d0, d1, d2);
     }
 
-template<class T> void Dynamic_Array4<T>::resize(int d0, int d1, int d2, int d3)
+template<class T> void DynamicArray4<T>::resize(int d0, int d1, int d2, int d3)
     {
     assert(!this->partial);
     this->do_destruct();
@@ -155,7 +155,7 @@ template<class T> void Dynamic_Array4<T>::resize(int d0, int d1, int d2, int d3)
     }
 
 
-template<class T> T& Dynamic_Array1<T>::operator[](int d0)
+template<class T> T& DynamicArray1<T>::operator[](int d0)
     { 
 #if !defined (NDEBUG)
     assert(this->elements != 0 && "Trying to dereference undefined array");
@@ -165,41 +165,41 @@ template<class T> T& Dynamic_Array1<T>::operator[](int d0)
     return this->elements[d0];
     }
 
-template<class T>  Dynamic_Array1<T> Dynamic_Array2<T>::operator[](int d0)
+template<class T>  DynamicArray1<T> DynamicArray2<T>::operator[](int d0)
     { 
 #if !defined (NDEBUG)
     assert(this->elements != 0 && "Trying to dereference undefined array");
     assert(0 <= d0 && d0 < this->bounds[0] && "Array subscript out of bounds");
 #endif
 
-    Dynamic_Array1<T> result;
+    DynamicArray1<T> result;
     result.bounds = this->bounds+1;
     result.elements = this->elements + this->bounds[1] * d0;
     result.partial = true;
     return result;
     }
 
-template<class T>  Dynamic_Array2<T> Dynamic_Array3<T>::operator[](int d0)
+template<class T>  DynamicArray2<T> DynamicArray3<T>::operator[](int d0)
     { 
 #if !defined (NDEBUG)
     assert(this->elements != 0 && "Trying to dereference undefined array");
     assert(0 <= d0 && d0 < this->bounds[0] && "Array subscript out of bounds");
 #endif
-    Dynamic_Array2<T> result;
+    DynamicArray2<T> result;
     result.bounds = this->bounds+1;
     result.elements = this->elements + this->bounds[1] * this->bounds[2] * d0;
     result.partial = true;
     return result;
     } 
 
-template<class T>  Dynamic_Array3<T> Dynamic_Array4<T>::operator[](int d0)
+template<class T>  DynamicArray3<T> DynamicArray4<T>::operator[](int d0)
     { 
 #if !defined (NDEBUG)
     assert(this->elements != 0 && "Trying to dereference undefined array");
     assert(0 <= d0 && d0 < this->bounds[0] && "Array subscript out of bounds");
 #endif
 
-    Dynamic_Array3<T> result;
+    DynamicArray3<T> result;
     result.bounds = this->bounds+1;
     result.elements = this->elements + this->bounds[1] * this->bounds[2] * this->bounds[3] * d0;
     result.partial = true;
@@ -208,7 +208,7 @@ template<class T>  Dynamic_Array3<T> Dynamic_Array4<T>::operator[](int d0)
 
 
 template<class T, int d> 
-    Dynamic_Array<T,d>::Dynamic_Array(Dynamic_Array<T,d> &D)
+    DynamicArray<T,d>::DynamicArray(DynamicArray<T,d> &D)
     {
     assert(D.elements != 0 && "Trying to copy an undefined array");
     partial = true;
diff --git a/omegalib/omega/include/basic/DynamicArray.h b/omegalib/omega/include/basic/DynamicArray.h
new file mode 100644
index 0000000..ac9bae4
--- /dev/null
+++ b/omegalib/omega/include/basic/DynamicArray.h
@@ -0,0 +1,103 @@
+#ifndef Already_Included_DynamicArray
+#define Already_Included_DynamicArray
+
+namespace omega {
+
+template <class T> class DynamicArray2;
+template <class T> class DynamicArray3;
+template <class T> class DynamicArray4;
+
+template <class T, int d> class DynamicArray
+    {
+    public:
+	DynamicArray(DynamicArray<T,d> &D);
+        ~DynamicArray();
+
+    protected:
+	DynamicArray();
+	bool partial;
+	int *bounds;
+	T *elements;
+
+	void do_constr();
+	void do_destruct();
+    };
+
+
+template <class T> class DynamicArray1 : public DynamicArray<T,1>
+    {
+    public:
+	DynamicArray1(const char *s0 = 0);
+	DynamicArray1(int d0);
+	void resize(int d0);
+        T& operator[](int d);
+
+	friend class DynamicArray2<T>;
+
+    private:
+	void do_construct(int d0);
+    };
+
+
+template <class T> class DynamicArray2 : public DynamicArray<T,2>
+    {
+    public:
+	DynamicArray2(const char *s0 = 0, const char *s1 = 0);
+	DynamicArray2(int d0, int d1);
+	void resize(int d0, int d1);
+  	DynamicArray1<T> operator[](int d);
+
+	friend class DynamicArray3<T>;
+
+    private:
+	void do_construct(int d0, int d1);
+    };
+
+
+template <class T> class DynamicArray3 : public DynamicArray<T,3>
+    {
+    public:
+	DynamicArray3(const char *s0 = 0, const char *s1 = 0, const char *s2 = 0);
+	DynamicArray3(int d0, int d1, int d2);
+	void resize(int d0, int d1, int d2);
+  	DynamicArray2<T> operator[](int d);
+
+	friend class DynamicArray4<T>;
+
+    private:
+	void do_construct(int d0, int d1, int d2);
+    };
+
+template <class T> class DynamicArray4 : public DynamicArray<T,4>
+    {
+    public:
+	DynamicArray4(const char *s0 = 0, const char *s1 = 0, const char *s2 = 0, const char *s3 = 0);
+	DynamicArray4(int d0, int d1, int d2, int d3);
+	void resize(int d0, int d1, int d2, int d3);
+  	DynamicArray3<T> operator[](int d);
+
+    private:
+	void do_construct(int d0, int d1, int d2, int d3);
+    };
+
+} // namespace
+
+#if ! defined DONT_INCLUDE_TEMPLATE_CODE
+#include <basic/DynamicArray.c>
+#endif
+
+#define instantiate_DynamicArray1(T)	template class DynamicArray1<T>; \
+					template class DynamicArray<T,1>;
+
+#define instantiate_DynamicArray2(T)	template class DynamicArray2<T>;  \
+					template class DynamicArray<T,2>; \
+					instantiate_DynamicArray1(T);
+
+#define instantiate_DynamicArray3(T)	template class DynamicArray3<T>;  \
+					template class DynamicArray<T,3>; \
+					instantiate_DynamicArray2(T);
+
+#define instantiate_DynamicArray4(T)	template class DynamicArray4<T>;  \
+					template class DynamicArray<T,4>; \
+					instantiate_DynamicArray3(T);
+#endif
diff --git a/omegalib/omega/include/basic/Dynamic_Array.h b/omegalib/omega/include/basic/Dynamic_Array.h
deleted file mode 100644
index c0bdf12..0000000
--- a/omegalib/omega/include/basic/Dynamic_Array.h
+++ /dev/null
@@ -1,103 +0,0 @@
-#ifndef Already_Included_Dynamic_Array
-#define Already_Included_Dynamic_Array
-
-namespace omega {
-
-template <class T> class Dynamic_Array2;
-template <class T> class Dynamic_Array3;
-template <class T> class Dynamic_Array4;
-
-template <class T, int d> class Dynamic_Array
-    {
-    public:
-	Dynamic_Array(Dynamic_Array<T,d> &D);
-        ~Dynamic_Array();
-
-    protected:
-	Dynamic_Array();
-	bool partial;
-	int *bounds;
-	T *elements;
-
-	void do_constr();
-	void do_destruct();
-    };
-
-
-template <class T> class Dynamic_Array1 : public Dynamic_Array<T,1>
-    {
-    public:
-	Dynamic_Array1(const char *s0 = 0);
-	Dynamic_Array1(int d0);
-	void resize(int d0);
-        T& operator[](int d);
-
-	friend class Dynamic_Array2<T>;
-
-    private:
-	void do_construct(int d0);
-    };
-
-
-template <class T> class Dynamic_Array2 : public Dynamic_Array<T,2>
-    {
-    public:
-	Dynamic_Array2(const char *s0 = 0, const char *s1 = 0);
-	Dynamic_Array2(int d0, int d1);
-	void resize(int d0, int d1);
-  	Dynamic_Array1<T> operator[](int d);
-
-	friend class Dynamic_Array3<T>;
-
-    private:
-	void do_construct(int d0, int d1);
-    };
-
-
-template <class T> class Dynamic_Array3 : public Dynamic_Array<T,3>
-    {
-    public:
-	Dynamic_Array3(const char *s0 = 0, const char *s1 = 0, const char *s2 = 0);
-	Dynamic_Array3(int d0, int d1, int d2);
-	void resize(int d0, int d1, int d2);
-  	Dynamic_Array2<T> operator[](int d);
-
-	friend class Dynamic_Array4<T>;
-
-    private:
-	void do_construct(int d0, int d1, int d2);
-    };
-
-template <class T> class Dynamic_Array4 : public Dynamic_Array<T,4>
-    {
-    public:
-	Dynamic_Array4(const char *s0 = 0, const char *s1 = 0, const char *s2 = 0, const char *s3 = 0);
-	Dynamic_Array4(int d0, int d1, int d2, int d3);
-	void resize(int d0, int d1, int d2, int d3);
-  	Dynamic_Array3<T> operator[](int d);
-
-    private:
-	void do_construct(int d0, int d1, int d2, int d3);
-    };
-
-} // namespace
-
-#if ! defined DONT_INCLUDE_TEMPLATE_CODE
-#include <basic/Dynamic_Array.c>
-#endif
-
-#define instantiate_Dynamic_Array1(T)	template class Dynamic_Array1<T>; \
-					template class Dynamic_Array<T,1>;
-
-#define instantiate_Dynamic_Array2(T)	template class Dynamic_Array2<T>;  \
-					template class Dynamic_Array<T,2>; \
-					instantiate_Dynamic_Array1(T);
-
-#define instantiate_Dynamic_Array3(T)	template class Dynamic_Array3<T>;  \
-					template class Dynamic_Array<T,3>; \
-					instantiate_Dynamic_Array2(T);
-
-#define instantiate_Dynamic_Array4(T)	template class Dynamic_Array4<T>;  \
-					template class Dynamic_Array<T,4>; \
-					instantiate_Dynamic_Array3(T);
-#endif
diff --git a/omegalib/omega/include/basic/Iterator.h b/omegalib/omega/include/basic/Iterator.h
index 8975d9e..f62874c 100644
--- a/omegalib/omega/include/basic/Iterator.h
+++ b/omegalib/omega/include/basic/Iterator.h
@@ -16,24 +16,24 @@ namespace omega {
 
 #define foreachSeparated(x,T,S,A,B) do {for (omega::Any_Iterator<T> __P_##x = (S).any_iterator();__P_##x;) {T & x = *__P_##x; A; __P_##x++; if (__P_##x) B;}} while (0)
 
-/*
- * Abstract base class Iterator<type>
+/*!
+ * \brief Abstract base class Iterator<type>
+ * 
  * Supports two styles of iteration:
- *
+ * ~~~
  *    for ( ... initialize i (typically i = collection) ...  ; i ; i++ )
  *        operate_on(*i)
- *
+ * ~~~
  * or
- *
+ * ~~~
  *    for ( ... initialize i ... ; i.live() ; i.next() )
  *        operate_on(i.curr())
- *
- *   >>> IF THE COLLECTION IS CHANGED, THE ITERATOR IS NO LONGER VALID <<<
+ * ~~~
+ * **IF THE COLLECTION IS CHANGED, THE ITERATOR IS NO LONGER VALID**
  *
  * For collections that are not "Sequence"s, the order in
  *  which the elements are returned may not be consistent.
  */
-
 template<class T> class Iterator {
 public:
     virtual const T &  operator*() const = 0;
@@ -54,9 +54,8 @@ public:
 };
 
 
-// A generator is like an iterator but it gives out values,
-// which may or may not exist in some writable collection
-
+//! A generator is like an iterator but it gives out values
+/*! Values may or may not exist in some writable collection */
 template<class T> class Generator {
 public:
     virtual       T    operator*() const = 0;
@@ -74,14 +73,13 @@ public:
 
 
 
-// Delegate to any kind of iterator (on the heap)
-// If created via a reference, become a copy of the iterator
-// If created via a pointer, manipulate that pointer and free *p when this dies
-//
-// Mostly useful for Collection::iterator
-// Iterator::Iterator(Collection)
-
-
+//! Delegate to any kind of iterator (on the heap)
+/*!
+ * * If created via a reference, become a copy of the iterator
+ * * If created via a pointer, manipulate that pointer and free *p when this dies
+ * 
+ * Mostly useful for Collection::iterator `Iterator::Iterator(Collection)`
+ */
 template<class T> class Any_Iterator : public Iterator<T> {
 public:
     Any_Iterator(Collection<T> &c);
@@ -101,13 +99,13 @@ public:
     Iterator<T> *new_copy() const	{ return new Any_Iterator<T>((*me).new_copy()); }
 
 private:
-    Any_Iterator(Iterator<T> *p)  // take over *p, *p MUST BE ON THE HEAP
-    { me = p; }
+    //! take over *p, *p MUST BE ON THE HEAP
+    Any_Iterator(Iterator<T> *p) { me = p; }
     friend class Collection<T>;
-#if 0  
-    // Couldn't make this work with g++258
-    friend Any_Iterator<T> Collection<T>::any_iterator();
-#endif    
+/* 
+ *   // Couldn't make this work with g++258
+ *   friend Any_Iterator<T> Collection<T>::any_iterator();
+ */
     Iterator<T> *me;
 };
 
diff --git a/omegalib/omega/include/basic/Link.h b/omegalib/omega/include/basic/Link.h
index ede7a2b..bdf169c 100644
--- a/omegalib/omega/include/basic/Link.h
+++ b/omegalib/omega/include/basic/Link.h
@@ -16,20 +16,19 @@ namespace omega {
 #endif
 #endif
 
-/* 
-   List_Element: one item in a list and the pointer to the next.
-   Each such object should be pointed to by either exactly one
-    other List_Element or by some other pointer(s), exactly one
-    of which will delete the List_Element.
-   ListElements should ONLY be allocated on the heap.
- */
-
 #if ListElementFreeList
   // g++ 2.5.8 does not allow static data in template classes, so...
   extern void *kludgy_List_Element_new(size_t size);
   extern void  kludgy_List_Element_delete(void *ptr, size_t size);
 #endif
-
+/*! 
+ * \brief List_Element: one item in a list and the pointer to the next.
+ *
+ * Each such object should be pointed to by either exactly one
+ * other List_Element or by some other pointer(s), exactly one
+ * of which will delete the List_Element.
+ * ListElements should ONLY be allocated on the heap.
+ */
 template <class T> class List_Element {
 public:
 #if ListElementFreeList
diff --git a/omegalib/omega/include/basic/List.h b/omegalib/omega/include/basic/List.h
index c6fc062..ee394d9 100644
--- a/omegalib/omega/include/basic/List.h
+++ b/omegalib/omega/include/basic/List.h
@@ -4,11 +4,6 @@
 /*
  *  Linked lists with an interface like a bit of libg++'s SLList class
  */
-
-
-#if 0
-#include <basic/assert.h> /* List requires assert which needs Exit which */
-#endif                    /* needs List!  just include assert in List.c  */
 #include <stdio.h>  // for NULL
 #include <basic/Iterator.h>
 #include <basic/Collection.h>
diff --git a/omegalib/omega/include/omega/reach.h b/omegalib/omega/include/omega/reach.h
index ff4bf79..76d7dee 100644
--- a/omegalib/omega/include/omega/reach.h
+++ b/omegalib/omega/include/omega/reach.h
@@ -7,15 +7,15 @@ class reachable_information {
 public:
 	Tuple<std::string> node_names;
 	Tuple<int> node_arity;
-	Dynamic_Array1<Relation> start_nodes;
-	Dynamic_Array2<Relation> transitions;
+	DynamicArray1<Relation> start_nodes;
+	DynamicArray2<Relation> transitions;
 };
 
 
-Dynamic_Array1<Relation> *
+DynamicArray1<Relation> *
 Reachable_Nodes(reachable_information * reachable_info);
 
-Dynamic_Array1<Relation> *
+DynamicArray1<Relation> *
 I_Reachable_Nodes(reachable_information * reachable_info);
 
 } // namespace
diff --git a/omegalib/omega/src/reach.cc b/omegalib/omega/src/reach.cc
index bde785c..6569edb 100644
--- a/omegalib/omega/src/reach.cc
+++ b/omegalib/omega/src/reach.cc
@@ -1,12 +1,12 @@
 #include <omega.h>
 #include <omega/Relations.h>
-#include <basic/Dynamic_Array.h>
+#include <basic/DynamicArray.h>
 #include <omega/reach.h>
 
 namespace omega {
 
-typedef Dynamic_Array1<Relation> Rel_Array1;
-typedef Dynamic_Array2<Relation> Rel_Array2;
+typedef DynamicArray1<Relation> Rel_Array1;
+typedef DynamicArray2<Relation> Rel_Array2;
 
 // This is from parallelism.c, modified