[Top][All Lists]
[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[PATCH] Convert Domain/ documentation to doxygen recognizable format
|
From: |
Richard Guenther |
|
Subject: |
[PATCH] Convert Domain/ documentation to doxygen recognizable format |
|
Date: |
Sun, 5 Oct 2003 17:16:05 +0200 (CEST) |
Hi!
This patch (as an example) converts the inline documentation of the
Domain/ sources to a doxygen recognizable format. I didnt bother to clean
this up for now (you will notice different "styles" of doxygen markup)
until we can agree on the principle of this patch. Also I'll be glad to
write up a README on the preferred documentation markup once we have
decided on one. I for myself prefer java-doc like (///) for methods and
doxygen like (/** */) for files/classes, as they tend to stick out some
more and structure the source.
Any comments? Does anyone think this is useful work?
Thanks,
Richard.
A ChangeLog would read
* .../Domain/*.h: convert comments to doxygen recognizable style.
The patch is just a diff of my -doc repository against cvs head (Domain/
parts).
diff -ur cvs/r2/src/Domain/AllDomain.h pooma-doc/r2/src/Domain/AllDomain.h
--- cvs/r2/src/Domain/AllDomain.h 2003-03-18 21:11:44.000000000 +0100
+++ pooma-doc/r2/src/Domain/AllDomain.h 2003-10-05 17:03:45.000000000 +0200
@@ -38,7 +38,8 @@
//////////////////////////////////////////////////////////////////////
//-----------------------------------------------------------------------------
-// Overview:
+/** @file
+ * @ingroup Domain
//
// AllDomain is one of the domain wildcards, which are used when constructing
// other domains using specific combination rules. AllDomain means to use
@@ -46,7 +47,7 @@
// domain. It is also used when constructing new domains with no other
// arguments to mean that the domain should not be initialized, which can
// save considerable time in some circumstances.
-//
+*/
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
@@ -67,7 +68,7 @@
//-----------------------------------------------------------------------------
//
-// Full Description of AllDomain:
+/**
//
// AllDomain is a special domain class which is used as a 'wildcard'.
// Wildcards are useful when constructing new domains based on some other
@@ -86,7 +87,7 @@
// dimensions should not be initialized, which can be helpful to avoid
// extra unneeded work when the domain will be filled with new values very
// soon.
-//
+*/
//-----------------------------------------------------------------------------
template<int Dim>
@@ -171,7 +172,7 @@
//-----------------------------------------------------------------------------
//
-// Full Description:
+/**
//
// DomainTraits<AllDomain<Dim>> provides traits information about AllDomain,
// which is one of the domain wildcards. It has a quite stripped-down
@@ -180,7 +181,7 @@
// dimension and the type of the wildcard, and an enum indicating that it is
// a wildcard. Also, getDomain returns a 1D element of the N-dimensional
// list of wildcards.
-//
+*/
//-----------------------------------------------------------------------------
template<int Dim>
Only in cvs/r2/src/Domain: CVS
diff -ur cvs/r2/src/Domain/CombineDomainOpt.h
pooma-doc/r2/src/Domain/CombineDomainOpt.h
--- cvs/r2/src/Domain/CombineDomainOpt.h 2000-03-07 14:16:33.000000000
+0100
+++ pooma-doc/r2/src/Domain/CombineDomainOpt.h 2003-01-16 20:46:35.000000000
+0100
@@ -36,9 +36,14 @@
//////////////////////////////////////////////////////////////////////
-//-----------------------------------------------------------------------------
-// Overview:
-//
+/** @file
+ * @ingroup Domain
+ * @brief
+ * CombineDomainOpt is a class that can be used to optimize the operation
+ * NewDomainN<>::combineSlice(domain, s1, s2, ...).
+ */
+
+/**
// CombineDomainOpt is a class that can be used to optimize the operation
// NewDomainN<>::combineSlice(domain, s1, s2, ...).
//
@@ -60,6 +65,7 @@
// );
//
// If s is single-valued, the array a is never used.
+*/
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
@@ -69,10 +75,12 @@
template<class NewDomain, bool sv>
struct CombineDomainOpt;
+/**
// Single valued specialization.
// Since Locs can construct themselves from other Locs and
// integers, we just use the constructors. Another option is
// return Loc<dim>(s1, s2, ...).
+*/
template<class NewDomain>
struct CombineDomainOpt<NewDomain, true>
@@ -143,8 +151,10 @@
}
};
+/**
// Multi-valued version. This one calls combineSlice to create
// the final domain.
+*/
template<class NewDomain>
struct CombineDomainOpt<NewDomain, false>
diff -ur cvs/r2/src/Domain/Contains.h pooma-doc/r2/src/Domain/Contains.h
--- cvs/r2/src/Domain/Contains.h 2003-05-20 22:08:59.000000000 +0200
+++ pooma-doc/r2/src/Domain/Contains.h 2003-10-05 17:07:48.000000000 +0200
@@ -39,15 +39,18 @@
//////////////////////////////////////////////////////////////////////
-//-----------------------------------------------------------------------------
-// Overview:
-// bool contains(domain,domain) is a global function which determines if
-// the points in the second domain are all points which are in the first
-// domain. If there is even just one point in the second not in the first,
-// then this returns false. Note that the order is important: if
-// contains(a,b) is true, then the only way that contains(b,a) can be true is
-// if a == b. The order for the query is: is b contained within a?
-//-----------------------------------------------------------------------------
+/** @file
+ * @ingroup Domain
+ * @brief
+ * bool contains(domain,domain) is a global function which determines if
+ * the points in the second domain are all points which are in the first
+ * domain.
+ *
+ * If there is even just one point in the second not in the first,
+ * then this returns false. Note that the order is important: if
+ * contains(a,b) is true, then the only way that contains(b,a) can be true is
+ * if a == b. The order for the query is: is b contained within a?
+ */
//-----------------------------------------------------------------------------
// Typedefs:
@@ -68,7 +71,7 @@
//-----------------------------------------------------------------------------
//
-// Full Description of ContainsDomainSingle:
+/**
//
// ContainsDomainSingle<T1,T2,bool strided>::contains(a,b) compares two
// domains a and b of type T1 and T2, and returns true if a contains b.
@@ -85,13 +88,13 @@
// found in a. The striding of a may lead to it not
// referring to points in b. Only do this calculation when
// absolutely necessary.
-//
+*/
//-----------------------------------------------------------------------------
-//
+/**
// The default (unit-stride) version of ContainsDomainSingle, which assumes
// that both arguments to 'contains' are 1D domains with unit stride
-//
+*/
template<class T1, class T2, bool strided>
struct ContainsDomainSingle {
@@ -100,10 +103,10 @@
}
};
-//
+/**
// The non-unit-stride version of ContainsDomainSingle, which does extra
// work for the case where a and b do not have unit stride.
-//
+*/
template<class T1, class T2>
struct ContainsDomainSingle<T1,T2,true> {
@@ -143,7 +146,7 @@
//-----------------------------------------------------------------------------
//
-// Full Description of ContainsDomain:
+/**
//
// ContainsDomain implements a basic template meta-program to
// compare each dimension separately of the multidimensional domains for
@@ -152,7 +155,7 @@
// or not. A general version of ContainsDomain is defined, to compare the
// domains in the 'Dim' dimension, and then a specialization is provided
// for Dim==1 that stops the metaprogram recursion.
-//
+*/
//-----------------------------------------------------------------------------
template<class T1, class T2, int Dim>
@@ -198,7 +201,7 @@
//-----------------------------------------------------------------------------
//
-// Full Description of contains:
+/**
//
// bool contains(domain1, domain2) is one of the domain calculus routines
// used to analyze domains to determine their relative characteristics. It
@@ -208,7 +211,7 @@
// The implementation of contains is deferred to the ContainsDomain
// struct, which performs the contains comparison for each dimension and and's
// the results together.
-//
+*/
//-----------------------------------------------------------------------------
template<class T1, class T2>
diff -ur cvs/r2/src/Domain/Domain.h pooma-doc/r2/src/Domain/Domain.h
--- cvs/r2/src/Domain/Domain.h 2003-01-23 22:29:49.000000000 +0100
+++ pooma-doc/r2/src/Domain/Domain.h 2003-01-31 18:26:30.000000000 +0100
@@ -37,7 +37,8 @@
//////////////////////////////////////////////////////////////////////
//-----------------------------------------------------------------------------
-// Overview:
+/** @file
+ * @ingroup Domain
// Domain is a base class for all domain objects, but one which can be
// specialized for N-dimensional (N>1), and 1-dimensional domain objects.
// The first template parameter is a dimension, which is used
@@ -50,6 +51,7 @@
// which are common to all Domain objects, regardless of whether they are
// 1-D or N-D domains, are collected into the DomainBase class which is a
// base class for Domain.
+*/
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
@@ -71,7 +73,7 @@
//-----------------------------------------------------------------------------
//
-// Full Description:
+/**
//
// Domain<Dim,DT> provides the bulk of the public interface for all domain
// objects. The first template parameter is a dimension that
@@ -102,13 +104,13 @@
// on what the dimension is.
//
// Domain<N,DT> defines the following operations for domain objects:
-// operator[]
-// operator+=, -=, *=, /=
-// operator++, operator-- : just like using += stride(), -= stride()
+// - operator[]
+// - operator+=, -=, *=, /=
+// - operator++, operator-- : just like using += stride(), -= stride()
// for each dimension
-// int size()
-// bool empty()
-// operator <, == (other comparisons defined in DomainBase.h)
+// - int size()
+// - bool empty()
+// - operator <, == (other comparisons defined in DomainBase.h)
//
// Note that if some operation is not defined for a particular type of
// domain (e.g., *=, which is not legal for Loc or Interval objects), the
@@ -119,70 +121,67 @@
//
// Domain<1,DT> defines, in addition to the Domain<N,DT> methods, these
// extra interface functions for just 1D domains:
-// int first(), last(), stride(), min(), max()
-// long length()
+// - int first(), last(), stride(), min(), max()
+// - long length()
//
// The actual data for the domain (such as what the endpoints are) is
// kept in DomainBase. The DomainTraits class defines what the type
// of the storage should be. By putting that storage in the base class,
// we avoid the 'empty base class' penalty of many compilers. The storage
// object is named domain_m.
-//
+*/
//-----------------------------------------------------------------------------
template<int Dim, class DT>
class Domain : public DomainBase<DT>
{
- // convenience typedef
+ /// convenience typedef
typedef DomainBase<DT> Base_t;
public:
//
- // Typedefs obtained from the DomainBase and DomainTraits.
+ /// Typedefs obtained from the DomainBase and DomainTraits.
//
typedef typename DT::Size_t Size_t;
typedef typename Base_t::Domain_t Domain_t;
typedef typename DT::OneDomain_t OneDomain_t;
- // Iterator typedefs. An N-dimensional iterator is a forward
- // iterator, it works only with operator++ (it does not have operator--).
+ /// Iterator typedefs. An N-dimensional iterator is a forward
+ /// iterator, it works only with operator++ (it does not have operator--).
typedef typename Base_t::const_iterator const_iterator;
typedef typename Base_t::iterator iterator;
- // Block iterator typedefs. All domains use the DomainBlockIterator
- // class to iterate through blocks defined by the domain points. A
- // block iterator is a forward iterator, it works only with operator++.
+ /// Block iterator typedefs. All domains use the DomainBlockIterator
+ /// class to iterate through blocks defined by the domain points. A
+ /// block iterator is a forward iterator, it works only with operator++.
typedef typename Base_t::const_blockIterator const_blockIterator;
typedef typename Base_t::blockIterator blockIterator;
- //
- // Constructors. Domain has a default constructor, which only
- // makes sure for now that the Dim parameter is consistent with the
- // DT parameter. The storage object is kept and initialized in DomainBase.
- //
+ /**
+ * Constructors. Domain has a default constructor, which only
+ * makes sure for now that the Dim parameter is consistent with the
+ * DT parameter. The storage object is kept and initialized in DomainBase.
+ */
inline
Domain() {
CTAssert(DT::dimensions == Dim && Dim > 0);
}
- //
- // If an Pooma::NoInit object is given in the constructor, we skip
- // initialization of our array of 1D domains.
- //
+ /**
+ * If an Pooma::NoInit object is given in the constructor, we skip
+ * initialization of our array of 1D domains.
+ */
inline Domain(const Pooma::NoInit &d) : Base_t(d) {
CTAssert(DT::dimensions == Dim && Dim > 0);
}
- //
- // Destructor. Here, nothing to do
- //
-
+ /** Destructor. Here, nothing to do. */
inline
~Domain() { }
@@ -190,14 +189,18 @@
// Domain accessors.
//
- // return the Nth element of this domain, using []
+ /// return the Nth element of this domain, using []
inline
const OneDomain_t &operator[](int d) const { return this->domain_m[d]; }
+
+ /// return the Nth element of this domain, using []
inline
OneDomain_t &operator[](int d) { return this->domain_m[d]; }
+ /**
// return the total size of the domain, which is the product
// of all the lengths of the 1D domains
+ */
inline
Size_t size() const {
Size_t sz = this->domain_m[0].size();
@@ -206,8 +209,8 @@
return sz;
}
- // return if this domain is empty, which reports whether any of the
- // N 1-dimensional domains are empty.
+ /** return if this domain is empty, which reports whether any of the
+ * N 1-dimensional domains are empty. */
inline
bool empty() const {
for (int i = 0; i < Dim; i++)
@@ -216,14 +219,14 @@
return false;
}
- // return whether this domain has been initialized. This is the
- // same as saying it is not empty.
+ /** return whether this domain has been initialized. This is the
+ * same as saying it is not empty. */
inline
bool initialized() const { return (!empty()); }
- //
- // Comparison operators ==, !=, <, >, <=, >=
- //
+
+ /// @name Comparison operators ==, !=, <, >, <=, >=
+ //@{
template<class T>
bool operator==(const T &d2) const {
@@ -279,14 +282,17 @@
return true;
}
- //
- // Arithmetic accumulation operators. These are only allowed to
- // occur with domain objects which are single-valued and have the
- // right number of dimensions (basically, Loc's and scalar's).
- //
- // All return a reference to this object, but cast down to the
- // derived type (e.g., Loc<N> instead of Domain<DomainTraits<Loc<N>>>
- //
+ //@}
+
+ /// @name Arithmetic accumulation operators
+ /// These are only allowed to
+ /// occur with domain objects which are single-valued and have the
+ /// right number of dimensions (basically, Loc's and scalar's).
+ ///
+ /// All return a reference to this object, but cast down to the
+ /// derived type (e.g., Loc<N> instead of Domain<DomainTraits<Loc<N>>>
+
+ //@{
template<class T>
Domain_t &operator+=(const T &d2)
@@ -331,11 +337,13 @@
return this->unwrap();
}
+ //@}
+
private:
- // make the copy constructor and operator= private and undefined
- // so that they will not be generated and so it will be an error if
- // the user tries to use them. The classes derived from Domain should
- // provide all the constructors and operator='s needed.
+ /** make the copy constructor and operator= private and undefined
+ * so that they will not be generated and so it will be an error if
+ * the user tries to use them. The classes derived from Domain should
+ * provide all the constructors and operator='s needed. */
Domain(const Domain<Dim,DT> &);
void operator=(const Domain<Dim,DT> &);
};
@@ -343,7 +351,7 @@
//-----------------------------------------------------------------------------
//
-// Full Description: SetDomainFunctor
+/**
//
// SetDomainFunctor is a simple wrapper around the setDomain method in
// the DomainTraits class. It is templated on the DomainTraits type,
@@ -357,7 +365,7 @@
// setWildcardDomain method is available which takes an extra user-supplied
// reference domain. This reference domain is used by the wildcard to
// calculate what the true domain should be.
-//
+*/
//-----------------------------------------------------------------------------
template<class DT, class ST, class T, class UT, bool wildcard>
@@ -387,13 +395,13 @@
//-----------------------------------------------------------------------------
//
-// Full Description:
+/**
//
// The 1D-specialized version of Domain, which acts much like the ND version
// but also provides a number of new or redefined interface functions:
// int first(), last(), stride(), min(), max()
// long length()
-//
+*/
//-----------------------------------------------------------------------------
template<class DT>
diff -ur cvs/r2/src/Domain/DomainArithOpsTraits.h
pooma-doc/r2/src/Domain/DomainArithOpsTraits.h
--- cvs/r2/src/Domain/DomainArithOpsTraits.h 2001-06-28 21:08:10.000000000
+0200
+++ pooma-doc/r2/src/Domain/DomainArithOpsTraits.h 2003-01-16
20:46:35.000000000 +0100
@@ -37,33 +37,30 @@
//////////////////////////////////////////////////////////////////////
-//-----------------------------------------------------------------------------
-// Overview:
-// DomainArithOpsTraits is intended to be used to select the return type of
-// arithmetic operations between domains and pseudo-domains comprising the
following
-// list:
-
-// Loc<1> Loc<N> Interval<N> Range<N> IndirectionList<int> Grid<N>
-
-// Valid combinations are
-
-// Loc<1> +-*/ Loc<1> => Loc<1>
-// Loc<1> +-*/ Loc<N> => Loc<N>
-// Loc<1> +-*/ Interval<N> => Interval<N>
-// Loc<1> +-*/ Range<N> => Range<N>
-// Loc<1> +-*/ IndirectionList<int> => IndirectionList<int>
-// Loc<1> +-*/ Grid<N> => Grid<N>
-
-// Loc<N> +-*/ Loc<N> => Loc<N>
-// Loc<N> +-*/ Interval<N> => Interval<N>
-// Loc<N> +-*/ Range<N> => Range<N>
-// Loc<N> +-*/ Grid<N> => Grid<N>
-
-
-
-
-
-//-----------------------------------------------------------------------------
+/** @file
+ * @ingroup Domain
+ * @brief
+ * DomainArithOpsTraits is intended to be used to select the return type of
+ * arithmetic operations between domains and pseudo-domains.
+ *
+ * DomainArithOpsTraits comprises the following list:
+ *
+ * Loc<1> Loc<N> Interval<N> Range<N> IndirectionList<int> Grid<N>
+ *
+ * Valid combinations are
+ *
+ * Loc<1> + - * / Loc<1> => Loc<1>
+ * Loc<1> + - * / Loc<N> => Loc<N>
+ * Loc<1> + - * / Interval<N> => Interval<N>
+ * Loc<1> + - * / Range<N> => Range<N>
+ * Loc<1> + - * / IndirectionList<int> => IndirectionList<int>
+ * Loc<1> + - * / Grid<N> => Grid<N>
+ *
+ * Loc<N> + - * / Loc<N> => Loc<N>
+ * Loc<N> + - * / Interval<N> => Interval<N>
+ * Loc<N> + - * / Range<N> => Range<N>
+ * Loc<N> + - * / Grid<N> => Grid<N>
+ */
//-----------------------------------------------------------------------------
// Typedefs:
diff -ur cvs/r2/src/Domain/DomainBase.h pooma-doc/r2/src/Domain/DomainBase.h
--- cvs/r2/src/Domain/DomainBase.h 2001-04-13 04:12:59.000000000 +0200
+++ pooma-doc/r2/src/Domain/DomainBase.h 2003-01-16 20:46:35.000000000
+0100
@@ -36,17 +36,20 @@
//////////////////////////////////////////////////////////////////////
-//-----------------------------------------------------------------------------
-// Overview:
-// DomainBase is a common base class for all domain objects. The template
-// parameter T should be a traits class that describes all the
-// characteristics of the domain object, and the dimension of the object.
-// This base class provides a collection of all the functionality that is
-// common to all DomainBase-derived objects, regardless of whether they are
-// specialized to a specific number of dimensions or not. For example, both
-// Domain<N, DomainTraits<Loc<N>>> and Domain<1, DomainTraits<Loc<N>>>
-// use DomainBase as a base class.
-//-----------------------------------------------------------------------------
+/** @file
+ * @ingroup Domain
+ * @brief
+ * DomainBase is a common base class for all domain objects.
+ *
+ * The template
+ * parameter T should be a traits class that describes all the
+ * characteristics of the domain object, and the dimension of the object.
+ * This base class provides a collection of all the functionality that is
+ * common to all DomainBase-derived objects, regardless of whether they are
+ * specialized to a specific number of dimensions or not. For example, both
+ * Domain<N, DomainTraits<Loc<N>>> and Domain<1, DomainTraits<Loc<N>>>
+ * use DomainBase as a base class.
+ */
//-----------------------------------------------------------------------------
// Typedefs:
@@ -70,7 +73,7 @@
//-----------------------------------------------------------------------------
//
-// Full Description:
+/**
//
// DomainBase<DT> is the common base class for all Domain<Dim, DT> objects,
// regardless of the value of Dim. Since Domain<Dim,DT> is defined for
@@ -124,7 +127,7 @@
// the format for printing a domain is "[" followed by first():last():stride()
// for each dimension, followed by "]". For example, a 2D Range with the
// same sequence 1 ... 9 step 2 would be "[1:9:2,1:9:2]"
-//
+*/
//-----------------------------------------------------------------------------
template<class DT>
diff -ur cvs/r2/src/Domain/DomainBlockIterator.h
pooma-doc/r2/src/Domain/DomainBlockIterator.h
--- cvs/r2/src/Domain/DomainBlockIterator.h 2003-03-18 21:11:44.000000000
+0100
+++ pooma-doc/r2/src/Domain/DomainBlockIterator.h 2003-10-05
17:03:45.000000000 +0200
@@ -34,12 +34,12 @@
// DomainBlockIterator<Dom>
//-----------------------------------------------------------------------------
-//-----------------------------------------------------------------------------
-// Overview:
-//
-// DomainBlockIterator<Dom> - Iterates through domain data (of type Dom),
-// and returns block domains (Interval or Region)
-//-----------------------------------------------------------------------------
+/** @file
+ * @ingroup Domain
+ * @brief
+ * DomainBlockIterator<Dom> - Iterates through domain data (of type Dom),
+ * and returns block domains (Interval or Region)
+ */
//-----------------------------------------------------------------------------
// Includes:
@@ -50,8 +50,7 @@
//-----------------------------------------------------------------------------
//
-// Full Description:
-// DomainBlockIterator<Dom>
+/**
//
// A simple iterator class to iterate through all of the points
// in a given domain of type Dom. This iterator returns Interval or
@@ -75,7 +74,7 @@
//
// This is an input-iterator, in the STL sense. It only defines deref,
// ->, and ++ operators.
-//
+*/
//-----------------------------------------------------------------------------
diff -ur cvs/r2/src/Domain/DomainCalculus.h
pooma-doc/r2/src/Domain/DomainCalculus.h
--- cvs/r2/src/Domain/DomainCalculus.h 2000-03-07 14:16:34.000000000 +0100
+++ pooma-doc/r2/src/Domain/DomainCalculus.h 2003-01-16 20:46:35.000000000
+0100
@@ -37,12 +37,13 @@
//////////////////////////////////////////////////////////////////////
-//-----------------------------------------------------------------------------
-// Overview:
-// This file defines the prototypes for routines used in the domain
-// calculus computations. These routines are not part of the main user
-// API, they are mainly for the domain calculus implementation.
-//-----------------------------------------------------------------------------
+/** @file
+ * @ingroup Domain
+ * @brief
+ * This file defines the prototypes for routines used in the domain
+ * calculus computations. These routines are not part of the main user
+ * API, they are mainly for the domain calculus implementation.
+ */
//-----------------------------------------------------------------------------
// Typedefs:
@@ -56,17 +57,20 @@
// Forward Declarations:
//-----------------------------------------------------------------------------
+/**
// findLeftCommonEndpoint is used by the domain calculus routines to
// find the leftmost common endpoint for two domains defined by
// [a0:a1:s] and [b0:b1:t]. If an endpoint is possible, this returns
// true and the endpoint in the final argument. If one is not possible,
// due to incompatible striding, this returns false and leaves the final
// argument unchanged.
+*/
extern
bool findLeftCommonEndpoint(int a0, int a1, int s, int b0, int b1, int t,
int &endpoint);
+/**
// findIntersectionEndpoints is used by the domain calculus routines to
// find the endpoints and stride of an intersection domain given
// two other strided domains defined by [a0:a1:s] and [b0:b1:t]. If
@@ -75,6 +79,7 @@
// is possible, due to incompatible striding, this returns false and
// leaves the final arguments unchanged. Note that if a domain is returned,
// it will always be true that i0 <= i1, is > 0.
+*/
extern
bool findIntersectionEndpoints(int a0, int a1, int s, int b0, int b1, int t,
diff -ur cvs/r2/src/Domain/DomainIterator.h
pooma-doc/r2/src/Domain/DomainIterator.h
--- cvs/r2/src/Domain/DomainIterator.h 2003-03-18 21:11:44.000000000 +0100
+++ pooma-doc/r2/src/Domain/DomainIterator.h 2003-10-05 17:03:45.000000000
+0200
@@ -34,11 +34,11 @@
// DomainIterator<Dom>
//-----------------------------------------------------------------------------
-//-----------------------------------------------------------------------------
-// Overview:
-//
-// DomainIterator<Dom> - Iterates through domain data (of type Dom)
-//-----------------------------------------------------------------------------
+/** @file
+ * @ingroup Domain
+ * @brief
+ * DomainIterator<Dom> - Iterates through domain data (of type Dom)
+ */
//-----------------------------------------------------------------------------
// Includes:
@@ -52,7 +52,7 @@
//-----------------------------------------------------------------------------
//
-// Full Description:
+/**
// DomainIterator<Dom>
//
// A simple iterator class to iterate through all of the points
@@ -61,7 +61,7 @@
//
// This is an input-iterator, in the STL sense. It only defines deref,
// ->, and ++ operators.
-//
+*/
//-----------------------------------------------------------------------------
diff -ur cvs/r2/src/Domain/DomainMap.h pooma-doc/r2/src/Domain/DomainMap.h
--- cvs/r2/src/Domain/DomainMap.h 2001-04-13 04:12:59.000000000 +0200
+++ pooma-doc/r2/src/Domain/DomainMap.h 2003-01-16 20:46:35.000000000 +0100
@@ -34,16 +34,17 @@
// DomainMap<Domain,Data>
//-----------------------------------------------------------------------------
-//-----------------------------------------------------------------------------
-// DomainMap Overview:
-//
-// DomainMap<Domain,Data> stores a list of N domains (of type Domain), each
-// with an associated piece of data (of type Data). The domains are stored
-// in a tree-like structure which makes it efficient to find all subdomains
-// which touch a given domain. Using a tree, the touch operation can be done
-// in O(log(N)) time instead of O(N), since the domains are sorted.
-//
-//-----------------------------------------------------------------------------
+/** @file
+ * @ingroup Domain
+ * @brief
+ * DomainMap<Domain,Data> stores a list of N domains (of type Domain), each
+ * with an associated piece of data (of type Data).
+ *
+ * The domains are stored
+ * in a tree-like structure which makes it efficient to find all subdomains
+ * which touch a given domain. Using a tree, the touch operation can be done
+ * in O(log(N)) time instead of O(N), since the domains are sorted.
+ */
//-----------------------------------------------------------------------------
// Include Files
@@ -61,7 +62,7 @@
//-----------------------------------------------------------------------------
//
-// Full Description:
+/**
//
// DomainMap<Domain,Data> is templated on the type of domains it is storing,
// and the Data type it stores for each Domain. The purpose of DomainMap
@@ -128,7 +129,7 @@
// a begin/end pair which can be used to iterate through all subdomains which
// touch the domain given to the 'touch' method. touch_iterator has
// forward-iterator semantics, and dereferencing returns a Value_t pair.
-//
+*/
//-----------------------------------------------------------------------------
///////////////////////////////////////////////////////////////////////////////
@@ -136,12 +137,13 @@
//-----------------------------------------------------------------------------
-// DomainMapNode Overview:
+/**
//
// DomainMapNode is a node in a tree, where each Node has a list of domains
// and a left and right branch. This class is pooled since it will be
// created and deleted often. It contains methods for finding the left
// and right nodes in its leaves.
+*/
//-----------------------------------------------------------------------------
template<class Dom, class T>
@@ -299,13 +301,14 @@
//-----------------------------------------------------------------------------
-// DomainMapIterator Overview:
+/**
//
// An iterator for a DomainMap. This has forward-iterator semantics. It
// is initially given a starting node and location in that node's list of
// elements; it will iterate through the elements in the node, and then move
// on to the next node until there are no nodes left. When it reaches the
// end, it sets node pointer to 0.
+*/
//-----------------------------------------------------------------------------
template<class Dom, class T>
@@ -380,7 +383,7 @@
//-----------------------------------------------------------------------------
-// DomainMapConstIterator Overview:
+/**
//
// An iterator for a DomainMap. This has forward-iterator semantics. It
// is initially given a starting node and location in that node's list of
@@ -390,6 +393,7 @@
//
// This is the const version of the iterator, so that the deref operator
// returns a copy of instead of a reference to the data.
+*/
//-----------------------------------------------------------------------------
template<class Dom, class T>
@@ -464,12 +468,13 @@
//-----------------------------------------------------------------------------
-// DomainMapTouchIterator Overview:
+/**
//
// The touch iterator for a DomainMap. This has forward-iterator semantics.
// This is similar to the regular DomainMapIterator, except that it only
// returns domains which touch a given domain. There is no const version
// of this class.
+*/
//-----------------------------------------------------------------------------
template<class Dom, class T>
@@ -550,8 +555,10 @@
//-----------------------------------------------------------------------------
+/**
// The final class we need to define, DomainMap. This uses the
// Node and Iterator classes defined previously.
+*/
//-----------------------------------------------------------------------------
template<class Dom, class T>
@@ -765,10 +772,10 @@
//-----------------------------------------------------------------------------
-//
+/**
// A specialization of the Inform traits used to say that DomainMap has
// a print method.
-//
+*/
//-----------------------------------------------------------------------------
template <class Dom, class T>
diff -ur cvs/r2/src/Domain/DomainRemoveOverlap.h
pooma-doc/r2/src/Domain/DomainRemoveOverlap.h
--- cvs/r2/src/Domain/DomainRemoveOverlap.h 2001-03-29 02:41:21.000000000
+0200
+++ pooma-doc/r2/src/Domain/DomainRemoveOverlap.h 2003-01-16
20:46:35.000000000 +0100
@@ -34,6 +34,12 @@
#include <iostream>
#include <iterator>
+/** @file
+ * @ingroup Domain
+ * @brief
+ * TBD.
+ */
+
template <int Dim>
std::vector<Interval<Dim> >
DomainRemoveOverlap(const Interval<Dim> & s,const Interval<Dim> &r)
diff -ur cvs/r2/src/Domain/DomainTraits.Grid.h
pooma-doc/r2/src/Domain/DomainTraits.Grid.h
--- cvs/r2/src/Domain/DomainTraits.Grid.h 2003-05-20 21:30:30.000000000
+0200
+++ pooma-doc/r2/src/Domain/DomainTraits.Grid.h 2003-10-05 17:07:48.000000000
+0200
@@ -37,14 +37,17 @@
//////////////////////////////////////////////////////////////////////
-//-----------------------------------------------------------------------------
-// Overview:
-// DomainTraits<Grid<N>> is a specialization of the general DomainTraits
-// class, for the case of Grid domain objects. It defines the general
-// behavior of Grid, including its typedef and static data
-// characteristics, how to store data for a Grid, etc. It is used by the
-// Domain base class of Grid to implement most of the public interface.
-//-----------------------------------------------------------------------------
+/** @file
+ * @ingroup Domain
+ * @brief
+ * DomainTraits<Grid<N>> is a specialization of the general DomainTraits
+ * class, for the case of Grid domain objects.
+ *
+ * It defines the general
+ * behavior of Grid, including its typedef and static data
+ * characteristics, how to store data for a Grid, etc. It is used by the
+ * Domain base class of Grid to implement most of the public interface.
+ */
//-----------------------------------------------------------------------------
// Typedefs:
@@ -75,7 +78,7 @@
//-----------------------------------------------------------------------------
//
-// Full Description:
+/**
//
// DomainTraits<Grid<Dim>> stores the characteristics and much of the
// implementation details for Grid domain objects. A Grid represents
@@ -93,13 +96,15 @@
// for a domain object is only available for 1D versions of that domain
// object, the Grid<1> specialization defines more interface functions than
// the Grid<Dim> case.
-//
+*/
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
+/**
// DomainTraits<Grid<Dim>>:
// The specialization of DomainTraits for Grid, for dimensions greater than
// one.
+*/
//-----------------------------------------------------------------------------
template<int Dim>
@@ -154,8 +159,10 @@
//-----------------------------------------------------------------------------
+/**
// DomainTraits<Grid<1>>:
// The specialization of DomainTraits for Grid, for dimension == 1.
+*/
//-----------------------------------------------------------------------------
template<>
@@ -357,12 +364,12 @@
//-----------------------------------------------------------------------------
//
-// Full Description:
+/**
//
// DomainChangeDim<T, int> is used to convert from a domain of one dimension
// to another dimension (the second template parameter).
// For Grid<Dim1>, it changes from Dim1 to Dim2.
-//
+*/
//-----------------------------------------------------------------------------
template<int Dim1, int Dim2>
Only in cvs/r2/src/Domain: DomainTraits.Grid.h.orig
diff -ur cvs/r2/src/Domain/DomainTraits.Interval.h
pooma-doc/r2/src/Domain/DomainTraits.Interval.h
--- cvs/r2/src/Domain/DomainTraits.Interval.h 2003-05-20 21:30:30.000000000
+0200
+++ pooma-doc/r2/src/Domain/DomainTraits.Interval.h 2003-10-05
17:07:48.000000000 +0200
@@ -37,14 +37,17 @@
//////////////////////////////////////////////////////////////////////
-//-----------------------------------------------------------------------------
-// Overview:
-// DomainTraits<Interval<N>> is a specialization of the general DomainTraits
-// class, for the case of Interval domain objects. It defines the general
-// behavior of Interval, including its typedef and static data
-// characteristics, how to store data for a Interval, etc. It is used by the
-// Domain base class of Interval to implement most of the public interface.
-//-----------------------------------------------------------------------------
+/** @file
+ * @ingroup Domain
+ * @brief
+ * DomainTraits<Interval<N>> is a specialization of the general DomainTraits
+ * class, for the case of Interval domain objects.
+ *
+ * It defines the general
+ * behavior of Interval, including its typedef and static data
+ * characteristics, how to store data for a Interval, etc. It is used by the
+ * Domain base class of Interval to implement most of the public interface.
+ */
//-----------------------------------------------------------------------------
// Typedefs:
@@ -72,7 +75,7 @@
//-----------------------------------------------------------------------------
//
-// Full Description:
+/**
//
// DomainTraits<Interval<Dim>> stores the characteristics and much of the
// implementation details for Interval domain objects. An Interval represents
@@ -87,13 +90,15 @@
// for a domain object is only available for 1D versions of that domain
// object, the Interval<1> specialization defines more interface functions than
// the Interval<Dim> case.
-//
+*/
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
+/**
// DomainTraits<Interval<Dim>>:
// The specialization of DomainTraits for Interval, for dimensions greater than
// one.
+*/
//-----------------------------------------------------------------------------
template<int Dim>
@@ -152,8 +157,10 @@
//-----------------------------------------------------------------------------
+/**
// DomainTraits<Interval<1>>:
// The specialization of DomainTraits for Interval, for dimension == 1.
+*/
//-----------------------------------------------------------------------------
template<>
@@ -342,12 +349,12 @@
//-----------------------------------------------------------------------------
//
-// Full Description:
+/**
//
// DomainChangeDim<T, int> is used to convert from a domain of one dimension
// to another dimension (the second template parameter).
// For Interval<Dim1>, it changes from Dim1 to Dim2.
-//
+*/
//-----------------------------------------------------------------------------
template<int Dim1, int Dim2>
Only in cvs/r2/src/Domain: DomainTraits.Interval.h.orig
diff -ur cvs/r2/src/Domain/DomainTraits.Loc.h
pooma-doc/r2/src/Domain/DomainTraits.Loc.h
--- cvs/r2/src/Domain/DomainTraits.Loc.h 2003-05-20 21:30:30.000000000
+0200
+++ pooma-doc/r2/src/Domain/DomainTraits.Loc.h 2003-10-05 17:07:48.000000000
+0200
@@ -37,14 +37,31 @@
//////////////////////////////////////////////////////////////////////
-//-----------------------------------------------------------------------------
-// Overview:
-// DomainTraits<Loc<N>> is a specialization of the general DomainTraits
-// class, for the case of Loc domain objects. It defines the general
-// behavior of Loc, including its typedef and static data characteristics,
-// how to store data for a Loc, etc. It is used by the Domain base class
-// of Loc to implement most of the public interface.
-//-----------------------------------------------------------------------------
+/** @file
+ * @ingroup Domain
+ * @brief
+ * DomainTraits<Loc<N>> is a specialization of the general DomainTraits
+ * class, for the case of Loc domain objects.
+ *
+ * It defines the general
+ * behavior of Loc, including its typedef and static data characteristics,
+ * how to store data for a Loc, etc. It is used by the Domain base class
+ * of Loc to implement most of the public interface.
+ *
+// DomainTraits<Loc<Dim>> stores the characteristics and much of the
+// implementation details for Loc domain objects. A Loc acts like a
+// single integer point in N-dimensional space, so it is a single-valued,
+// unit-stride domain.
+//
+// A general version of DomainTraits<Loc<Dim>> is defined here, which
+// only includes the basic information to make Loc<Dim> look like an
+// array of Loc<1> objects. DomainTraits<Loc<1>> is a more specific
+// specialization which provides most of the necessary interface information
+// for items which need to know about Loc. Since most of the interface
+// for a domain object is only available for 1D versions of that domain
+// object, the Loc<1> specialization defines more interface functions than
+// the Loc<Dim> case.
+ */
//-----------------------------------------------------------------------------
// Typedefs:
@@ -69,29 +86,11 @@
//-----------------------------------------------------------------------------
-//
-// Full Description:
-//
-// DomainTraits<Loc<Dim>> stores the characteristics and much of the
-// implementation details for Loc domain objects. A Loc acts like a
-// single integer point in N-dimensional space, so it is a single-valued,
-// unit-stride domain.
-//
-// A general version of DomainTraits<Loc<Dim>> is defined here, which
-// only includes the basic information to make Loc<Dim> look like an
-// array of Loc<1> objects. DomainTraits<Loc<1>> is a more specific
-// specialization which provides most of the necessary interface information
-// for items which need to know about Loc. Since most of the interface
-// for a domain object is only available for 1D versions of that domain
-// object, the Loc<1> specialization defines more interface functions than
-// the Loc<Dim> case.
-//
-//-----------------------------------------------------------------------------
-
-//-----------------------------------------------------------------------------
+/**
// DomainTraits<Loc<Dim>>:
// The specialization of DomainTraits for Loc, for dimensions greater than
// one.
+*/
//-----------------------------------------------------------------------------
template<int Dim>
@@ -217,8 +216,10 @@
//-----------------------------------------------------------------------------
+/**
// DomainTraits<Loc<1>>:
// The specialization of DomainTraits for Loc, for dimension == 1.
+*/
//-----------------------------------------------------------------------------
template<>
@@ -405,12 +406,12 @@
//-----------------------------------------------------------------------------
//
-// Full Description:
+/**
//
// DomainChangeDim<T, int> is used to convert from a domain of one dimension
// to another dimension (the second template parameter).
// For Loc<Dim1>, it changes from Dim1 to Dim2.
-//
+*/
//-----------------------------------------------------------------------------
template<int Dim1, int Dim2>
Only in cvs/r2/src/Domain: DomainTraits.Loc.h.orig
diff -ur cvs/r2/src/Domain/DomainTraits.Range.h
pooma-doc/r2/src/Domain/DomainTraits.Range.h
--- cvs/r2/src/Domain/DomainTraits.Range.h 2003-05-20 21:30:30.000000000
+0200
+++ pooma-doc/r2/src/Domain/DomainTraits.Range.h 2003-10-05
17:07:48.000000000 +0200
@@ -37,14 +37,17 @@
//////////////////////////////////////////////////////////////////////
-//-----------------------------------------------------------------------------
-// Overview:
-// DomainTraits<Range<N>> is a specialization of the general DomainTraits
-// class, for the case of Range domain objects. It defines the general
-// behavior of Range, including its typedef and static data
-// characteristics, how to store data for a Range, etc. It is used by the
-// Domain base class of Range to implement most of the public interface.
-//-----------------------------------------------------------------------------
+/** @file
+ * @ingroup Domain
+ * @brief
+ * DomainTraits<Range<N>> is a specialization of the general DomainTraits
+ * class, for the case of Range domain objects.
+ *
+ * It defines the general
+ * behavior of Range, including its typedef and static data
+ * characteristics, how to store data for a Range, etc. It is used by the
+ * Domain base class of Range to implement most of the public interface.
+ */
//-----------------------------------------------------------------------------
// Typedefs:
@@ -72,7 +75,7 @@
//-----------------------------------------------------------------------------
//
-// Full Description:
+/**
//
// DomainTraits<Range<Dim>> stores the characteristics and much of the
// implementation details for Range domain objects. A Range represents
@@ -86,13 +89,15 @@
// for a domain object is only available for 1D versions of that domain
// object, the Range<1> specialization defines more interface functions than
// the Range<Dim> case.
-//
+*/
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
+/**
// DomainTraits<Range<Dim>>:
// The specialization of DomainTraits for Range, for dimensions greater than
// one.
+*/
//-----------------------------------------------------------------------------
template<int Dim>
@@ -353,12 +358,12 @@
//-----------------------------------------------------------------------------
//
-// Full Description:
+/**
//
// DomainChangeDim<T, int> is used to convert from a domain of one dimension
// to another dimension (the second template parameter).
// For Range<Dim1>, it changes from Dim1 to Dim2.
-//
+*/
//-----------------------------------------------------------------------------
template<int Dim1, int Dim2>
Only in cvs/r2/src/Domain: DomainTraits.Range.h.orig
diff -ur cvs/r2/src/Domain/DomainTraits.Region.h
pooma-doc/r2/src/Domain/DomainTraits.Region.h
--- cvs/r2/src/Domain/DomainTraits.Region.h 2003-05-20 21:30:30.000000000
+0200
+++ pooma-doc/r2/src/Domain/DomainTraits.Region.h 2003-10-05
17:07:48.000000000 +0200
@@ -37,14 +37,17 @@
//////////////////////////////////////////////////////////////////////
-//-----------------------------------------------------------------------------
-// Overview:
-// DomainTraits<Region<N,T>> is a specialization of the general DomainTraits
-// class, for the case of Region domain objects. It defines the general
-// behavior of Region, including its typedef and static data
-// characteristics, how to store data for a Region, etc. It is used by the
-// Domain base class of Region to implement most of the public interface.
-//-----------------------------------------------------------------------------
+/** @file
+ * @ingroup Domain
+ * @brief
+ * DomainTraits<Region<N,T>> is a specialization of the general DomainTraits
+ * class, for the case of Region domain objects.
+ *
+ * It defines the general
+ * behavior of Region, including its typedef and static data
+ * characteristics, how to store data for a Region, etc. It is used by the
+ * Domain base class of Region to implement most of the public interface.
+ */
//-----------------------------------------------------------------------------
// Typedefs:
@@ -69,7 +72,7 @@
//-----------------------------------------------------------------------------
//
-// Full Description:
+/**
//
// DomainTraits<Region<Dim,T>> stores the characteristics and much of the
// implementation details for Region domain objects. A Region represents
@@ -86,12 +89,14 @@
// for a domain object is only available for 1D versions of that domain
// object, the Region<1,T> specialization defines more interface functions than
// the Region<Dim,T> case.
-//
+*/
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
+/**
// DomainTraits<Region<Dim,T>>:
// The traits for an N-dimensional Region domain.
+*/
//-----------------------------------------------------------------------------
template<int Dim, class T>
@@ -145,8 +150,10 @@
//-----------------------------------------------------------------------------
+/**
// DomainTraits<Region<Dim,T>>:
// The traits for an 1-dimensional Region domain.
+*/
//-----------------------------------------------------------------------------
template<class T>
@@ -363,8 +370,10 @@
//-----------------------------------------------------------------------------
+/**
// DomainTraits<Region<1,POOMA_DEFAULT_POSITION_TYPE>>:
// The traits for an 1-dimensional Region of type POOMA_DEFAULT_POSITION_TYPE.
+*/
//-----------------------------------------------------------------------------
template<>
@@ -579,12 +588,12 @@
//-----------------------------------------------------------------------------
//
-// Full Description:
+/**
//
// DomainChangeDim<T, int> is used to convert from a domain of one dimension
// to another dimension (the second template parameter).
// For Region<Dim1>, it changes from Dim1 to Dim2.
-//
+*/
//-----------------------------------------------------------------------------
template<int Dim1, int Dim2, class T>
diff -ur cvs/r2/src/Domain/DomainTraits.SliceInterval.h
pooma-doc/r2/src/Domain/DomainTraits.SliceInterval.h
--- cvs/r2/src/Domain/DomainTraits.SliceInterval.h 2003-03-18
21:11:44.000000000 +0100
+++ pooma-doc/r2/src/Domain/DomainTraits.SliceInterval.h 2003-10-05
17:03:45.000000000 +0200
@@ -36,15 +36,17 @@
//////////////////////////////////////////////////////////////////////
-//-----------------------------------------------------------------------------
-// Overview:
-// DomainTraits<SliceInterval<Dim,SliceDim>> is a specialization of the
-// general DomainTraits class, for the case of SliceInterval domain objects.
-// It defines the general behavior of SliceInterval, including its typedef
-// and static data characteristics, how to store data for a SliceInterval, etc.
-// It is used by the SliceDomain base class of SliceInterval to implement most
-// of the public interface.
-//-----------------------------------------------------------------------------
+/** @file
+ * @ingroup Domain
+ * @brief
+ * DomainTraits<SliceInterval<Dim,SliceDim>> is a specialization of the
+ * general DomainTraits class, for the case of SliceInterval domain objects.
+ *
+ * It defines the general behavior of SliceInterval, including its typedef
+ * and static data characteristics, how to store data for a SliceInterval, etc.
+ * It is used by the SliceDomain base class of SliceInterval to implement most
+ * of the public interface.
+ */
//-----------------------------------------------------------------------------
// Typedefs:
@@ -67,7 +69,7 @@
//-----------------------------------------------------------------------------
//
-// Full Description:
+/**
//
// DomainTraits<SliceInterval<Dim,SliceDim>> stores the characteristics and
// much of the implementation details for SliceInterval domain objects.
@@ -91,7 +93,7 @@
//
// static OneDomain_t &getDomain(Domain_t &d, int n);
// static OneDomain_t &getSliceDomain(Domain_t &d, int n);
-//
+*/
//-----------------------------------------------------------------------------
template<int TotalDim, int SliceDim>
diff -ur cvs/r2/src/Domain/DomainTraits.SliceRange.h
pooma-doc/r2/src/Domain/DomainTraits.SliceRange.h
--- cvs/r2/src/Domain/DomainTraits.SliceRange.h 2003-03-18 21:11:44.000000000
+0100
+++ pooma-doc/r2/src/Domain/DomainTraits.SliceRange.h 2003-10-05
17:03:45.000000000 +0200
@@ -36,15 +36,17 @@
//////////////////////////////////////////////////////////////////////
-//-----------------------------------------------------------------------------
-// Overview:
-// DomainTraits<SliceRange<Dim,SliceDim>> is a specialization of the
-// general DomainTraits class, for the case of SliceRange domain objects.
-// It defines the general behavior of SliceRange, including its typedef
-// and static data characteristics, how to store data for a SliceRange, etc.
-// It is used by the SliceDomain base class of SliceRange to implement most
-// of the public interface.
-//-----------------------------------------------------------------------------
+/** @file
+ * @ingroup Domain
+ * @brief
+ * DomainTraits<SliceRange<Dim,SliceDim>> is a specialization of the
+ * general DomainTraits class, for the case of SliceRange domain objects.
+ *
+ * It defines the general behavior of SliceRange, including its typedef
+ * and static data characteristics, how to store data for a SliceRange, etc.
+ * It is used by the SliceDomain base class of SliceRange to implement most
+ * of the public interface.
+ */
//-----------------------------------------------------------------------------
// Typedefs:
@@ -67,7 +69,7 @@
//-----------------------------------------------------------------------------
//
-// Full Description:
+/**
//
// DomainTraits<SliceRange<Dim,SliceDim>> stores the characteristics and
// much of the implementation details for SliceRange domain objects.
@@ -91,7 +93,7 @@
//
// static OneDomain_t &getDomain(Domain_t &d, int n);
// static OneDomain_t &getSliceDomain(Domain_t &d, int n);
-//
+*/
//-----------------------------------------------------------------------------
template<int TotalDim, int SliceDim>
diff -ur cvs/r2/src/Domain/DomainTraits.h pooma-doc/r2/src/Domain/DomainTraits.h
--- cvs/r2/src/Domain/DomainTraits.h 2003-03-18 21:11:44.000000000 +0100
+++ pooma-doc/r2/src/Domain/DomainTraits.h 2003-10-05 17:03:45.000000000
+0200
@@ -39,19 +39,22 @@
//////////////////////////////////////////////////////////////////////
-//-----------------------------------------------------------------------------
-// Overview:
-// DomainTraits is a traits class for domain objects. This traits class
-// is used to specialize the Domain and DomainBase base classes for all
-// domain objects to do the proper action for that domain type, and to store
-// the proper information.
-//
-// DomainChangeDim is a simple struct used to convert a domain of type T
-// with a certain number of dimensions Dim1, to the same general type of
-// domain but with a different number of dimensions Dim2. It defines two
-// typedefs 'OldType_t' and 'NewType_t' with the type of domain with Dim1
-// and Dim2, respectively.
-//-----------------------------------------------------------------------------
+/** @file
+ * @ingroup Domain
+ * @brief
+ * DomainTraits is a traits class for domain objects. Includes DomainChangeDim.
+ *
+ * This traits class
+ * is used to specialize the Domain and DomainBase base classes for all
+ * domain objects to do the proper action for that domain type, and to store
+ * the proper information.
+ *
+ * DomainChangeDim is a simple struct used to convert a domain of type T
+ * with a certain number of dimensions Dim1, to the same general type of
+ * domain but with a different number of dimensions Dim2. It defines two
+ * typedefs 'OldType_t' and 'NewType_t' with the type of domain with Dim1
+ * and Dim2, respectively.
+ */
//-----------------------------------------------------------------------------
// Typedefs:
@@ -90,7 +93,7 @@
//-----------------------------------------------------------------------------
//
-// Full Description of DomainTraits<T>:
+/**
//
// DomainTraits<T> is a traits class which provides all the specific
// information and functionality to specialize how a given domain object
@@ -211,7 +214,7 @@
// ==> change the domain to the values in newdom, which should be
// a domain object with the proper interface, or an integer.
//
-// static void setDomain(Storage_t &dom, /** necessary args **/)
+// static void setDomain(Storage_t &dom, ** necessary args **)
// ==> change the domain to the values from a specialized list of
// information, which is domain-type specific. For example, for
// Range, this takes three extra args: first, last, stride
@@ -291,10 +294,11 @@
// If you need to provide special traits for
// any other scalars, then have the specialization of DomainTraits
// inherit from DomainTraitsScalar.
-//
+*/
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
+/**
// DomainTraitsDomain<DomT, T, Dim> can act as a base class for the partially-
// specialized versions of DomainTraits for domain-like classes, that is,
// classes which are derived from Domain. It it templated on the types to
@@ -303,6 +307,7 @@
// domain and dimensions, while the 1-D version also provided implementations
// of the static get* methods (such as getFirst, getMin, etc). Just inherit
// from DomainTraitsDomain if you're defining traits for a new Domain subclass.
+*/
//-----------------------------------------------------------------------------
// N-dimensional version of DomainTraitsDomain
@@ -323,7 +328,9 @@
static bool getIgnorable(const Domain_t &, int) { return false; }
};
+/**
// 1-dimensional specialized version of DomainTraitsDomain
+*/
template<class DomT, class T>
struct DomainTraitsDomain<DomT, T, 1>
{
@@ -366,6 +373,7 @@
//-----------------------------------------------------------------------------
+/**
// DomainTraitsScalar<DomT, T, NewDom1T> can act as a base class for partially
// specialized versions of DomainTraits for non-domain classes and types,
// such as the basic scalar types. It it templated on the types to use for
@@ -379,6 +387,7 @@
// for a scalar, the stride and length are always 1 and integers
// for a scalar, getEmpty() is always false
// for a scalar, getLoop() always returns 0 as an integer
+*/
//-----------------------------------------------------------------------------
template<class DomT, class T, class NewDom1T>
@@ -437,10 +446,10 @@
//-----------------------------------------------------------------------------
-//
+/**
// So now, finally, we can define the default version of DomainTraits<T>
// which just inherits from DomainTraitsScalar<T, T, T>
-//
+*/
//-----------------------------------------------------------------------------
template<class T>
@@ -470,7 +479,7 @@
//-----------------------------------------------------------------------------
//
-// Full Description of DomainChangeDim<T,Dim>:
+/**
//
// DomainChangeDim is a struct which is templated on a domain of type T,
// which has some original number of dimensions oldDim, and a new number
@@ -487,7 +496,7 @@
// We define here the basic form of the struct, but empty. Specialized
// domain types such define a partially specialized version of this struct
// with the above typedefs and static data relevant to that domain type.
-//
+*/
//-----------------------------------------------------------------------------
template<class T, int Dim>
@@ -502,7 +511,9 @@
};
+/**
// global function templates for invoking DomainTraits::setDomain()
+*/
template <class Dom, class Storage, class T1, class T2>
inline void
diff -ur cvs/r2/src/Domain/DomainTraits.int.h
pooma-doc/r2/src/Domain/DomainTraits.int.h
--- cvs/r2/src/Domain/DomainTraits.int.h 2001-04-13 04:12:59.000000000
+0200
+++ pooma-doc/r2/src/Domain/DomainTraits.int.h 2003-01-16 20:46:35.000000000
+0100
@@ -36,19 +36,22 @@
//////////////////////////////////////////////////////////////////////
-//-----------------------------------------------------------------------------
-// Overview:
-// DomainTraits<int> is a specialization of the general DomainTraits
-// class, for the case of integers. Integers can often be used in
-// combination with other domain types, and the traits class defines how
-// they interact with those other domains. Generally, an int gets promoted
-// to a Loc or Interval, based on the context, but in some cases the
-// int is used directly.
-//
-// This also defines the same kind of traits for long, char and short.
-// Both are treated just as if they were int's for Domain purposes. The
-// same is true for the unsigned versions of these integral types.
-//-----------------------------------------------------------------------------
+/** @file
+ * @ingroup Domain
+ * @brief
+ * DomainTraits<int> is a specialization of the general DomainTraits
+ * class, for the case of integers.
+ *
+ * Integers can often be used in
+ * combination with other domain types, and the traits class defines how
+ * they interact with those other domains. Generally, an int gets promoted
+ * to a Loc or Interval, based on the context, but in some cases the
+ * int is used directly.
+ *
+ * This also defines the same kind of traits for long, char and short.
+ * Both are treated just as if they were int's for Domain purposes. The
+ * same is true for the unsigned versions of these integral types.
+ */
//-----------------------------------------------------------------------------
// Typedefs:
@@ -71,7 +74,7 @@
//-----------------------------------------------------------------------------
//
-// Full Description:
+/**
//
// DomainTraits<int> stores the characteristics of integers when they are
// used to specify domains in expressions and object constructors. An int
@@ -87,6 +90,7 @@
// Identical traits are defined for long, char and short. Both integral types
// are treated just as if they were ints; they get converted to Interval
// or Loc objects in almost all cases. The same is true to unsigned versions.
+*/
//-----------------------------------------------------------------------------
template<>
diff -ur cvs/r2/src/Domain/EquivSubset.h pooma-doc/r2/src/Domain/EquivSubset.h
--- cvs/r2/src/Domain/EquivSubset.h 2003-05-20 22:08:59.000000000 +0200
+++ pooma-doc/r2/src/Domain/EquivSubset.h 2003-10-05 17:07:48.000000000
+0200
@@ -39,17 +39,20 @@
//////////////////////////////////////////////////////////////////////
-//-----------------------------------------------------------------------------
-// Overview:
-// domain4 equivSubset(domain1,domain2,domain3) is a global function
-// which finds the 'equivalent subset' for domain3 given a linear relationship
-// between domain1 and domain2. For example, given the relationship
-// I --> 2I - 1
-// and a domain 3J, then the equivalent subset is
-// 3J --> 2(3J) - 1 = 6J - 1
-// The returned domain type is the most general type which could hold
-// the data in the domains 1, 2 and 3.
-//-----------------------------------------------------------------------------
+/** @file
+ * @ingroup Domain
+ * @brief
+ * domain4 equivSubset(domain1,domain2,domain3) is a global function
+ * which finds the 'equivalent subset' for domain3 given a linear relationship
+ * between domain1 and domain2.
+ *
+ * For example, given the relationship
+ * I --> 2I - 1
+ * and a domain 3J, then the equivalent subset is
+ * 3J --> 2(3J) - 1 = 6J - 1
+ * The returned domain type is the most general type which could hold
+ * the data in the domains 1, 2 and 3.
+ */
//-----------------------------------------------------------------------------
// Typedefs:
@@ -71,7 +74,7 @@
//-----------------------------------------------------------------------------
//
-// Full Description of EquivSubsetDomainSingle:
+/**
//
// EquivSubsetDomainSingle<T1,T2,T3,T4,int Dim,bool strided>::equiv(a,b,c,d)
// finds the equivalent subset for c given the relationship between a and b,
@@ -80,16 +83,16 @@
// to the following two cases:
// strided == false: all the domains have unit stride.
// strided == true: one or more domains have non-unit stride.
-//
+*/
//-----------------------------------------------------------------------------
-//
+/**
// The default (unit-stride) version of EquivSubsetDomainSingle, which assumes
// that all arguments to 'equiv' are domains with unit stride. The fourth
// argument, the returned equivalent subset domain, is assumed to have been
// set equal to the third domain beforehand. It will be offset and
// scaled in the same way that the second is from the first.
-//
+*/
template<class T1, class T2, class T3, int Dim, bool strided>
struct EquivSubsetDomainSingle {
@@ -100,7 +103,7 @@
}
};
-//
+/**
// The non-unit-stride version of EquivSubsetDomainSingle, which does extra
// work for the case where a, b, or c do not have unit stride. The fourth
// argument, the returned equivalent subset domain, is assumed to have been
@@ -117,7 +120,7 @@
// using the first point in the domains a and b.
// 2. Apply the linear transformation to the third domain to get the fourth:
// d = m c + k
-//
+*/
template<class T1, class T2, class T3, int Dim>
struct EquivSubsetDomainSingle<T1,T2,T3,Dim,true> {
@@ -142,7 +145,7 @@
//-----------------------------------------------------------------------------
//
-// Full Description of EquivSubsetDomain:
+/**
//
// EquivSubsetDomain implements a basic template meta-program to find the
// equiv subset of each dimension separately of the multidimensional domains.
@@ -156,7 +159,7 @@
// c --> d in the same way that a --> b, we can set things here so that we
// first set d == c, and then modify d accordingly. So, this struct assumes
// that d == c already, and does not need to have c provided in another var.
-//
+*/
//-----------------------------------------------------------------------------
template<class T1, class T2, class T3, int Dim>
@@ -200,7 +203,7 @@
//-----------------------------------------------------------------------------
//
-// Full Description of equivSubset:
+/**
//
// domain4 equivSubset(domain1,domain2,domain3) is a global function
// which finds the 'equivalent subset' for domain3 given a linear relationship
@@ -216,15 +219,17 @@
// The implementation of equivSubset is deferred to the EquivSubsetDomain
// struct, which performs the intersection for each dimension and and's
// the results together.
-//
+*/
//-----------------------------------------------------------------------------
+/**
// first, a simple struct used to figure out the return type when examining
// types T1,T2,T3. It defines a typedef 'Type_t' for what the return type is.
// Note that we use the 'DomainChangeDim' mechanism after we find out the
// type when combining T1,T2,T3, since the combined type will have a
// dimension of dim(T1) + dim(T2) + dim(T3), and we want the dim to be
// the same as T1.
+*/
template<class T1, class T2, class T3>
struct EquivSubsetReturnType {
typedef typename NewDomain3<T1,T2,T3>::Type_t Combine_t;
@@ -232,7 +237,9 @@
DomainChangeDim<Combine_t,DomainTraits<T1>::dimensions>::NewType_t Type_t;
};
+/**
// now, finally, the intersect method
+*/
template<class T1, class T2, class T3>
inline typename EquivSubsetReturnType<T1,T2,T3>::Type_t
equivSubset(const T1 &a, const T2 &b, const T3 &c)
diff -ur cvs/r2/src/Domain/Grid.h pooma-doc/r2/src/Domain/Grid.h
--- cvs/r2/src/Domain/Grid.h 2003-03-18 21:11:44.000000000 +0100
+++ pooma-doc/r2/src/Domain/Grid.h 2003-10-05 17:03:45.000000000 +0200
@@ -36,18 +36,21 @@
//////////////////////////////////////////////////////////////////////
-//-----------------------------------------------------------------------------
-// Overview:
-// Grid is a general type of integer domain, which refers to a set of points
-// a0, a1, ... aN for each dimension. The points can be any ascending or
-// descending sequence, there is no fixed stride. This is basically a set
-// of Dim IndirectionList<int>'s, one for each dimension; the total domain
-// is the tensor product of these lists. Grid<Dim> is basically an array
-// of Grid<1> objects.
-//
-// Grid defers most of its implementation to the Domain<DomainTraits<Grid>>
-// base class.
-//-----------------------------------------------------------------------------
+/** @file
+ * @ingroup Domain
+ * @brief
+ * Grid is a general type of integer domain, which refers to a set of points
+ * a0, a1, ... aN for each dimension.
+ *
+ * The points can be any ascending or
+ * descending sequence, there is no fixed stride. This is basically a set
+ * of Dim IndirectionList<int>'s, one for each dimension; the total domain
+ * is the tensor product of these lists. Grid<Dim> is basically an array
+ * of Grid<1> objects.
+ *
+ * Grid defers most of its implementation to the Domain<DomainTraits<Grid>>
+ * base class.
+ */
//-----------------------------------------------------------------------------
// Typedefs:
@@ -71,7 +74,7 @@
//-----------------------------------------------------------------------------
//
-// Full Description of Grid:
+/**
//
// Grid<N> is a domain representing a set of N numeric sequences, one
// for each dimension N. The sequences are lists of ascending or descending
@@ -159,7 +162,7 @@
// after the general case that has different constructors.
//
// Grid inherits much of its activity from Domain<DomainTraits<Grid>>
-//
+*/
//-----------------------------------------------------------------------------
template<int Dim>
@@ -306,7 +309,7 @@
//-----------------------------------------------------------------------------
//
-// Full Description of Grid<1>:
+/*
//
// Grid<1> is a 1D specialization of Grid<N>; for the 1D case,
// there are only a restricted set of constructors available.
@@ -318,7 +321,7 @@
// Grid<1> a(m,n,s) - sets the Grid to the sequence [m ... n], stride s
// Grid<1> a(Domain d) : a Grid copied from d, which must be a
// 1D domain object.
-//
+*/
//-----------------------------------------------------------------------------
template<>
diff -ur cvs/r2/src/Domain/IndirectionList.h
pooma-doc/r2/src/Domain/IndirectionList.h
--- cvs/r2/src/Domain/IndirectionList.h 2003-03-18 21:11:44.000000000 +0100
+++ pooma-doc/r2/src/Domain/IndirectionList.h 2003-10-05 17:03:45.000000000
+0200
@@ -36,14 +36,16 @@
//////////////////////////////////////////////////////////////////////
-//-----------------------------------------------------------------------------
-// Overview:
-//
-// IndirectionList<T> is a class that takes any object with an
-// Array-like interface and stores the information as a list of elements
-// of type T. It is meant to store lists of indices for indirection-list
-// operations. T can be an int, or multidimensional items like Loc<Dim>.
-//-----------------------------------------------------------------------------
+/** @file
+ * @ingroup Domain
+ * @brief
+ * IndirectionList<T> is a class that takes any object with an
+ * Array-like interface and stores the information as a list of elements
+ * of type T.
+ *
+ * It is meant to store lists of indices for indirection-list
+ * operations. T can be an int, or multidimensional items like Loc<Dim>.
+ */
//-----------------------------------------------------------------------------
// Typedefs:
@@ -64,7 +66,7 @@
//-----------------------------------------------------------------------------
//
-// Full Description of IndirectionList:
+/**
//
// IndirectionList is a domain representing a N dimension set of integer
// sequences. It is always a 1D list, but can store data of multiple
@@ -121,7 +123,7 @@
// int min(), int max() - min or max of the endpoints.
// IndirectionList::iterator begin() and end() - return iterators for
// the 1D domain. These act like (at least) forward iterators.
-//
+*/
//-----------------------------------------------------------------------------
template<class T>
diff -ur cvs/r2/src/Domain/IndirectionListIterator.h
pooma-doc/r2/src/Domain/IndirectionListIterator.h
--- cvs/r2/src/Domain/IndirectionListIterator.h 2001-04-13 04:12:59.000000000
+0200
+++ pooma-doc/r2/src/Domain/IndirectionListIterator.h 2003-01-16
20:46:35.000000000 +0100
@@ -34,11 +34,11 @@
// IndirectionListIterator
//-----------------------------------------------------------------------------
-//-----------------------------------------------------------------------------
-// Overview:
-//
-// IndirectionListIterator - Iterates through IndirectionList<T> elements.
-//-----------------------------------------------------------------------------
+/** @file
+ * @ingroup Domain
+ * @brief
+ * IndirectionListIterator - Iterates through IndirectionList<T> elements.
+ */
//-----------------------------------------------------------------------------
// Includes:
@@ -58,12 +58,11 @@
//-----------------------------------------------------------------------------
//
-// Full Description:
-// IndirectionListIterator
+/**
//
// A random access iterator class that iterates through all of the elements
// of an IndirectionList<T>, returning T's when dereferenced.
-//
+*/
//-----------------------------------------------------------------------------
template <class T>
diff -ur cvs/r2/src/Domain/Intersect.h pooma-doc/r2/src/Domain/Intersect.h
--- cvs/r2/src/Domain/Intersect.h 2003-05-20 22:08:59.000000000 +0200
+++ pooma-doc/r2/src/Domain/Intersect.h 2003-10-05 17:07:48.000000000 +0200
@@ -39,16 +39,20 @@
//////////////////////////////////////////////////////////////////////
-//-----------------------------------------------------------------------------
-// Overview:
-// domain3 intersect(domain1,domain2) is a global function which determines if
-// two domains intersect with each other, and if so, what their
-// intersection is. By 'intersect', we mean the set of points which are
-// found in BOTH domains, expressed as a new domain. If they have no
-// points in common, this returns an empty domain. The type of domain
-// returned is the most general domain type which can store the information
-// from domain1 and domain2.
-//-----------------------------------------------------------------------------
+
+/** @file
+ * @ingroup Domain
+ * @brief
+ * domain3 intersect(domain1,domain2) is a global function which determines if
+ * two domains intersect with each other, and if so, what their
+ * intersection is.
+ *
+ * By 'intersect', we mean the set of points which are
+ * found in BOTH domains, expressed as a new domain. If they have no
+ * points in common, this returns an empty domain. The type of domain
+ * returned is the most general domain type which can store the information
+ * from domain1 and domain2.
+ */
//-----------------------------------------------------------------------------
// Typedefs:
@@ -71,7 +75,7 @@
//-----------------------------------------------------------------------------
//
-// Full Description of IntersectDomainSingle:
+/**
//
// IntersectDomainSingle<T1,T2,T3,int Dim,bool strided>::intersect(a,b,c)
// finds the intersection of two domains a and b of type T1 and T2, and
@@ -89,13 +93,13 @@
// they will not have any points in common due to the
// striding. We only do this long calculation when
// absolutely necessary.
-//
+*/
//-----------------------------------------------------------------------------
-//
+/**
// The default (unit-stride) version of IntersectDomainSingle, which assumes
// that both arguments to 'intersect' are 1D domains with unit stride
-//
+*/
template<class T1, class T2, class T3, int Dim, bool strided>
struct IntersectDomainSingle {
@@ -126,10 +130,10 @@
}
};
-//
+/**
// The non-unit-stride version of IntersectDomainSingle, which does extra
// work for the case where a or b do not have unit stride.
-//
+*/
template<class T1, class T2, class T3, int Dim>
struct IntersectDomainSingle<T1,T2,T3,Dim,true> {
@@ -180,7 +184,7 @@
//-----------------------------------------------------------------------------
//
-// Full Description of IntersectDomain:
+/**
//
// IntersectDomain implements a basic template meta-program to
// intersect each dimension separately of the multidimensional domains.
@@ -189,7 +193,7 @@
// or not. A general version of IntersectDomain is defined, to intersect the
// domains in the 'Dim' dimension, and then a specialization is provided
// for Dim==1 that stops the metaprogram recursion.
-//
+*/
//-----------------------------------------------------------------------------
template<class T1, class T2, class T3, int Dim>
@@ -235,7 +239,7 @@
//-----------------------------------------------------------------------------
//
-// Full Description of intersect:
+/**
//
// domain3 intersect(domain1,domain2) is a global function which determines if
// two domains intersect with each other, and if so, what their
@@ -250,14 +254,16 @@
// The implementation of intersect is deferred to the IntersectDomain
// struct, which performs the intersection for each dimension and and's
// the results together.
-//
+*/
//-----------------------------------------------------------------------------
+/**
// first, a simple struct used to figure out the return type when intersecting
// types T1 and T2. It defines a typedef 'Type_t' for what the return type is.
// Note that we use the 'DomainChangeDim' mechanism after we find out the
// type when combining T1 and T2, since the combined type will have a
// dimension of dim(T1) + dim(T2), and we want the dim to be the same as T1.
+*/
template<class T1, class T2>
struct IntersectReturnType {
typedef typename NewDomain2<T1,T2>::Type_t Combine_t;
@@ -265,7 +271,9 @@
DomainChangeDim<Combine_t,DomainTraits<T1>::dimensions>::NewType_t Type_t;
};
+/**
// now, finally, the intersect method
+*/
template<class T1, class T2>
inline typename IntersectReturnType<T1,T2>::Type_t
intersect(const T1 &a, const T2 &b)
diff -ur cvs/r2/src/Domain/Interval.h pooma-doc/r2/src/Domain/Interval.h
--- cvs/r2/src/Domain/Interval.h 2003-03-18 21:11:44.000000000 +0100
+++ pooma-doc/r2/src/Domain/Interval.h 2003-10-05 17:03:45.000000000 +0200
@@ -36,15 +36,17 @@
//////////////////////////////////////////////////////////////////////
-//-----------------------------------------------------------------------------
-// Overview:
-// Interval is a very simple type of domain, which refers to a set of points
-// a, a+1, a+2, ..., b. It has a hard-coded stride of 1. Interval<N>
-// is basically an array of Interval<1> objects.
-//
-// Interval defers most of its implementation to the
-// Domain<DomainTraits<Interval>> base class.
-//-----------------------------------------------------------------------------
+/** @file
+ * @ingroup Domain
+ * @brief
+ * Interval is a very simple type of domain, which refers to a set of points
+ * a, a+1, a+2, ..., b.
+ *
+ * It has a hard-coded stride of 1. Interval<N>
+ * is basically an array of Interval<1> objects.
+ * Interval defers most of its implementation to the
+ * Domain<DomainTraits<Interval>> base class.
+ */
//-----------------------------------------------------------------------------
// Typedefs:
@@ -66,7 +68,7 @@
//-----------------------------------------------------------------------------
//
-// Full Description of Interval:
+/**
//
// Interval<N> is a domain representing a set of N numeric sequences, one
// for each dimension N. The sequences have endpoints [a,b], and a
@@ -141,7 +143,7 @@
//
// For the special case of Interval<1>, there is a specialization given
// after the general case that has different constructors (listed above).
-//
+*/
//-----------------------------------------------------------------------------
template<int Dim>
@@ -276,7 +278,7 @@
//-----------------------------------------------------------------------------
//
-// Full Description of Interval<1>:
+/**
//
// Interval<1> is a 1D specialization of Interval<N>; for the 1D case,
// there are only a restricted set of constructors available.
@@ -287,7 +289,7 @@
// Interval<1> a(m,n) - sets the Interval to the sequence [m ... n]
// Interval<1> a(Domain d) - an Interval copied from d, which must be a
// 1D domain object.
-//
+*/
//-----------------------------------------------------------------------------
template<>
diff -ur cvs/r2/src/Domain/IntervalIterator.h
pooma-doc/r2/src/Domain/IntervalIterator.h
--- cvs/r2/src/Domain/IntervalIterator.h 2001-04-13 04:12:59.000000000
+0200
+++ pooma-doc/r2/src/Domain/IntervalIterator.h 2003-01-16 20:46:35.000000000
+0100
@@ -34,11 +34,11 @@
// IntervalIterator
//-----------------------------------------------------------------------------
-//-----------------------------------------------------------------------------
-// Overview:
-//
-// IntervalIterator - Iterates through Interval<1> points.
-//-----------------------------------------------------------------------------
+/** @file
+ * @ingroup Domain
+ * @brief
+ * IntervalIterator - Iterates through Interval<1> points.
+ */
//-----------------------------------------------------------------------------
// Includes:
@@ -58,12 +58,11 @@
//-----------------------------------------------------------------------------
//
-// Full Description:
-// IntervalIterator
+/**
//
// A random access iterator class that iterates through all of the points
// of an Interval<1>, returning ints when dereferenced.
-//
+*/
//-----------------------------------------------------------------------------
class IntervalIterator
diff -ur cvs/r2/src/Domain/IteratorPairDomain.h
pooma-doc/r2/src/Domain/IteratorPairDomain.h
--- cvs/r2/src/Domain/IteratorPairDomain.h 2003-03-18 21:11:44.000000000
+0100
+++ pooma-doc/r2/src/Domain/IteratorPairDomain.h 2003-10-05
17:03:45.000000000 +0200
@@ -77,18 +77,20 @@
namespace Pooma {
-//-----------------------------------------------------------------------------
-// Overview:
-//
-// IteratorPairDomain<Iter> wraps a pair of iterators and provides a
-// subset of services provided by other 1D domains, and in particular by
-// IndirectionList. It is meant to be used in places where
-// IndirectionList might be used, but it should be cheaper since it is
-// just storing a pair of iterators.
-//-----------------------------------------------------------------------------
+/** @file
+ * @ingroup Domain
+ * @brief
+ * IteratorPairDomain<Iter> wraps a pair of iterators and provides a
+ * subset of services provided by other 1D domains, and in particular by
+ * IndirectionList.
+ *
+ * It is meant to be used in places where
+ * IndirectionList might be used, but it should be cheaper since it is
+ * just storing a pair of iterators.
+ */
//-----------------------------------------------------------------------------
-// Full Description of IteratorPairDomain:
+/**
//
// Like IndirectionList<T>, IteratorPairDomain<T_Iter> provides access
// to an arbitrary sequence of T values. Rather than storing these in
@@ -161,6 +163,7 @@
// Iter end() - iterator to the end of the sequence.
// Element_t max() - returns the largest element (assumes operator<())
// Element_t min() - returns the smallest element (assumes operator<())
+*/
//-----------------------------------------------------------------------------
template <class Iter>
Only in cvs/r2/src/Domain: LINUXgcc
Only in cvs/r2/src/Domain: LINUXgcc295
Only in cvs/r2/src/Domain: LINUXgcc32
Only in cvs/r2/src/Domain: LINUXgcc32g
diff -ur cvs/r2/src/Domain/LeftDomain.h pooma-doc/r2/src/Domain/LeftDomain.h
--- cvs/r2/src/Domain/LeftDomain.h 2003-03-18 21:11:44.000000000 +0100
+++ pooma-doc/r2/src/Domain/LeftDomain.h 2003-10-05 17:03:45.000000000
+0200
@@ -37,18 +37,19 @@
//////////////////////////////////////////////////////////////////////
-//-----------------------------------------------------------------------------
-// Overview:
-//
-// LeftDomain is one of the domain wildcards, which are used when constructing
-// other domains using specific combination rules. LeftDomain means to use
-// the starting endpoint of the domain of a second 'reference' domain, with
-// a new user-provided right endpoint, when constructing a new
-// domain. It is also used when constructing new domains with no other
-// arguments to mean that the domain should not be initialized, which can
-// save considerable time in some circumstances.
-//
-//-----------------------------------------------------------------------------
+/** @file
+ * @ingroup Domain
+ * @brief
+ * LeftDomain is one of the domain wildcards, which are used when constructing
+ * other domains using specific combination rules.
+ *
+ * LeftDomain means to use
+ * the starting endpoint of the domain of a second 'reference' domain, with
+ * a new user-provided right endpoint, when constructing a new
+ * domain. It is also used when constructing new domains with no other
+ * arguments to mean that the domain should not be initialized, which can
+ * save considerable time in some circumstances.
+ */
//-----------------------------------------------------------------------------
// Typedefs:
@@ -69,7 +70,7 @@
//-----------------------------------------------------------------------------
//
-// Full Description of LeftDomain:
+/**
//
// LeftDomain is a special domain class which is used as a 'wildcard'.
// Wildcards are useful when constructing new domains based on some other
@@ -89,7 +90,7 @@
// dimensions should not be initialized, which can be helpful to avoid
// extra unneeded work when the domain will be filled with new values very
// soon.
-//
+*/
//-----------------------------------------------------------------------------
template<int Dim>
@@ -223,7 +224,7 @@
//-----------------------------------------------------------------------------
//
-// Full Description:
+/**
//
// DomainTraits<LeftDomain<Dim>> provides traits information about LeftDomain,
// which is one of the domain wildcards. It has a quite stripped-down
@@ -232,7 +233,7 @@
// dimension and the type of the wildcard, and an enum indicating that it is
// a wildcard. Also, getDomain returns a 1D element of the N-dimensional
// list of wildcards.
-//
+*/
//-----------------------------------------------------------------------------
template<int Dim>
diff -ur cvs/r2/src/Domain/Loc.h pooma-doc/r2/src/Domain/Loc.h
--- cvs/r2/src/Domain/Loc.h 2003-03-18 21:11:44.000000000 +0100
+++ pooma-doc/r2/src/Domain/Loc.h 2003-10-05 17:03:45.000000000 +0200
@@ -36,15 +36,16 @@
//////////////////////////////////////////////////////////////////////
-//-----------------------------------------------------------------------------
-// Overview:
-// Loc<N> is a very simple type of domain, which refers to just one point.
-// It acts very much like an N-dimensional vector of integers. It can be
-// used to refer to a single point along a sequence of points in a domain.
-//
-// Loc defers most of its implementation to the Domain<DomainTraits<Loc>>
-// base class.
-//-----------------------------------------------------------------------------
+/** @file
+ * @ingroup Domain
+ * @brief
+ * Loc<N> is a very simple type of domain, which refers to just one point.
+ *
+ * It acts very much like an N-dimensional vector of integers. It can be
+ * used to refer to a single point along a sequence of points in a domain.
+ * Loc defers most of its implementation to the Domain<DomainTraits<Loc>>
+ * base class.
+ */
//-----------------------------------------------------------------------------
// Typedefs:
@@ -68,7 +69,7 @@
//-----------------------------------------------------------------------------
//
-// Full Description of Loc:
+/**
//
// Loc<N> is a domain representing a single N-dimensional point. It has
// a stride of one, endpoints which are the same, and a single element.
@@ -137,16 +138,18 @@
// only contains Loc<N> constructors, destructor, and operator= methods.
// All other interface methods are in Domain, or in DomainBase (from
// which Domain inherits).
-//
+*/
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
+/**
// fillLocStorage descriptions:
// fillLocStorage is a function (actually a set of overloaded functions)
// that copies data from a given domain into a Loc. It will modify the
// second argument (the loc) starting at the index given by the first
// argument. The first argument will be incremented by the number of
// dimensions filled in to the Loc. This is defines for 1 ... 7 arguments.
+*/
//-----------------------------------------------------------------------------
template<int Dim, class T1>
@@ -222,12 +225,14 @@
//-----------------------------------------------------------------------------
+/**
// Full description of CopyLocStorage:
// CopyLocStorage is a simple struct with one static member 'copy' that
// copies data out of a given single domain into the given Loc. If the
// data is greater than 1D, only the dimensions of the given domain are copied.
// If the data is 1D, then the value of the domain is copied into all 'Dim'
// dimensions of the Loc. So there is a 1D specialization of CopyLocStorage.
+*/
//-----------------------------------------------------------------------------
template<int Dim, class T, int DimT, bool wildcard>
@@ -271,7 +276,9 @@
};
//-----------------------------------------------------------------------------
+/**
// N-Dimensional Loc class declaration and definition
+*/
//-----------------------------------------------------------------------------
template<int Dim>
@@ -464,7 +471,7 @@
//-----------------------------------------------------------------------------
//
-// Full Description of Loc<1>:
+/**
//
// Loc<1> is a 1D specialization of Loc<N>; for the 1D case,
// there are only a restricted set of constructors available.
@@ -472,7 +479,7 @@
// are defined:
// Loc<1> a() - default constructor, which creates a Loc<1> set to zero.
// Loc<1> a(n) - sets the Loc<1> to the point n
-//
+*/
//-----------------------------------------------------------------------------
template<>
diff -ur cvs/r2/src/Domain/NewDomain.h pooma-doc/r2/src/Domain/NewDomain.h
--- cvs/r2/src/Domain/NewDomain.h 2003-03-18 21:11:44.000000000 +0100
+++ pooma-doc/r2/src/Domain/NewDomain.h 2003-10-05 17:03:45.000000000 +0200
@@ -36,20 +36,23 @@
//////////////////////////////////////////////////////////////////////
-//-----------------------------------------------------------------------------
-// Overview:
-// A set of simple structs which tell how to combine different Domain
-// objects together. They are named NewDomain1 ... NewDomain7, are
-// templated on from 1 ... 7 different domain types, and provide the
-// following interface:
-// NewDomain2<T1,T2>::Type_t newdom; // resulting type when Domains combined
-// NewDomain2<T1,T2>::SliceType_t slicedom; // type for 'sliced' Dom's
-// newdom = NewDomain2<T1,T2>::combine(a,b); // combine a & b, return combo
-// NewDomain2<T1,T2>::fill(newdom, a, b); // combine a & b into newdom
-// slicedom = NewDomain2<T1,T2>::combineSlice(a,b); // 'slice' a & b
-// NewDomain2<T1,T2>::fillSlice(slicedom, a, b); // 'slice' into slicedom
-// similarly for NewDomain1, and NewDomain3 ... NewDomain7
-//-----------------------------------------------------------------------------
+/** @file
+ * @ingroup Domain
+ * @brief
+ * A set of simple structs which tell how to combine different Domain
+ * objects together.
+ *
+ * They are named NewDomain1 ... NewDomain7, are
+ * templated on from 1 ... 7 different domain types, and provide the
+ * following interface:
+ * NewDomain2<T1,T2>::Type_t newdom; // resulting type when Domains combined
+ * NewDomain2<T1,T2>::SliceType_t slicedom; // type for 'sliced' Dom's
+ * newdom = NewDomain2<T1,T2>::combine(a,b); // combine a & b, return combo
+ * NewDomain2<T1,T2>::fill(newdom, a, b); // combine a & b into newdom
+ * slicedom = NewDomain2<T1,T2>::combineSlice(a,b); // 'slice' a & b
+ * NewDomain2<T1,T2>::fillSlice(slicedom, a, b); // 'slice' into slicedom
+ * similarly for NewDomain1, and NewDomain3 ... NewDomain7
+ */
//-----------------------------------------------------------------------------
// Typedefs:
@@ -81,7 +84,7 @@
//-----------------------------------------------------------------------------
//
-// Full Description of CombineDomain:
+/**
//
// CombineDomain is a utility class used only by the 'fill*' methods
// of NewDomain2 ... NewDomain7. It is templated on the following params:
@@ -118,6 +121,7 @@
// and copies or modifies it based on the type of wildcard.
// if this is false, the CT domain is not a wildcard, and the user-
// supplied reference domain is ignored.
+*/
//-----------------------------------------------------------------------------
//
@@ -140,7 +144,7 @@
};
-//
+/**
// the general version of CombineSliceDomainWC ... this class is used
// by CombineSliceDomain to set up slice domain objects. It is similar
// to CombineDomain except that it will on occasion fill in a separate
@@ -148,7 +152,7 @@
// reference domain which is used by the wildcard to determine the correct
// domain. If no slicing is being done, and no wildcard is used, this
// just fills in the reduced 'slice domain'.
-//
+*/
template<class RT, class UT, class CT, int DS, int SliceDS,
bool incl, bool wc>
@@ -165,8 +169,10 @@
}
};
+/**
// specialization of CombineSliceDomainWC in which we fill in slice
// domain values and full domain values, but without using wildcards
+*/
template<class RT, class UT, class CT, int DS, int SliceDS>
struct CombineSliceDomainWC<RT,UT,CT,DS,SliceDS,true,false> {
enum { DRT = DomainTraits<RT>::dimensions };
@@ -185,8 +191,10 @@
}
};
+/**
// specialization of CombineSliceDomainWC in which we only fill in total
// domain values, using wildcards
+*/
template<class RT, class UT, class CT, int DS, int SliceDS>
struct CombineSliceDomainWC<RT,UT,CT,DS,SliceDS,false,true> {
enum { DRT = DomainTraits<RT>::dimensions };
@@ -204,8 +212,10 @@
}
};
+/**
// specialization of CombineSliceDomainWC in which we fill in slice
// domain values and full domain values, using wildcards
+*/
template<class RT, class UT, class CT, int DS, int SliceDS>
struct CombineSliceDomainWC<RT,UT,CT,DS,SliceDS,true,true> {
enum { DRT = DomainTraits<RT>::dimensions };
@@ -228,7 +238,7 @@
}
};
-//
+/**
// the general version of CombineSliceDomain ... by default, it just
// does the same thing as CombineDomain, except, for domains which store
// a slice, it will fill in a second 'total' domain with the extra info
@@ -239,7 +249,7 @@
// reference domain. To get all this done, CombineSliceDomain defers to
// a separate CombineSliceDomainWC struct which has an extra boolean
// template param 'wildcard' indicating whether to use wildcard set routines.
-//
+*/
template<class RT, class UT, class CT, int DS, int SliceDS, bool incl>
struct CombineSliceDomain {
@@ -252,7 +262,7 @@
//-----------------------------------------------------------------------------
//
-// Full Description of NewDomain1 ... NewDomain7:
+/**
//
// NewDomain2 ... NewDomain7 are simple helper structs which are used to
// combine Domain objects of different types together (when possible).
@@ -358,15 +368,17 @@
// So, to use NewDomainN objects, first determine what kind of combining
// rules you need in your particular context, and then use the relevant
// set of typedef and combine/fill methods from the list above.
-//
+*/
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
+/**
// A simple base class for all specialized NewDomain2 objects, defining
// the functions which all have in common. This is most easily done through
// a base class, since we need to define several different specializations
// of NewDomain2.
+*/
//-----------------------------------------------------------------------------
template<class T1, class T2, class TCombine, class TSCombine>
@@ -429,11 +441,13 @@
//-----------------------------------------------------------------------------
+/**
// The general version of NewDomain2. The allowed versions of NewDomain2
// are given as partial specializations of this general case. The general
// case assumes T1 and T2 are single-valued domains for which DomainTraits
// exist, that combine together to form Interval's (or Loc's for slice
// combine rules).
+*/
//-----------------------------------------------------------------------------
// first, create a simple struct used to add two dimensions together at
@@ -458,7 +472,7 @@
// Specific versions of NewDomain2, for all the allowed combinations.
//-----------------------------------------------------------------------------
-//
+/**
// macros for use in defining NewDomain2. The first sets up the
// combination of a domain with itself and with an int or Loc. The second
// sets up the combination of a domain with another domain of a different
@@ -479,7 +493,7 @@
// slice dimension
// 3. Combining a slice domain with any other non-slice domain increases
// both the total dimension and the slice dimension
-//
+*/
#define POOMA_NEWDOMAIN_SAME_SCALAR(DOM,SLICEDOM,S) \
template <int D> \
diff -ur cvs/r2/src/Domain/NullDomain.h pooma-doc/r2/src/Domain/NullDomain.h
--- cvs/r2/src/Domain/NullDomain.h 2000-06-21 02:12:33.000000000 +0200
+++ pooma-doc/r2/src/Domain/NullDomain.h 2003-01-16 20:46:35.000000000
+0100
@@ -37,11 +37,18 @@
#ifndef POOMA_DOMAIN_NULLDOMAIN_H
#define POOMA_DOMAIN_NULLDOMAIN_H
-//-----------------------------------------------------------------------------
-// NullDomain and ErrorDomain are special "domains". ErrorDomains result when
-// someone tries an incorrect domain calculation. NullDomain means a domain
-// with nothing in it.
-//-----------------------------------------------------------------------------
+/** @file
+ * @ingroup Domain
+ * @brief
+ * NullDomain and ErrorDomain special domains.
+ */
+
+//@{
+
+/** NullDomain and ErrorDomain are special "domains". ErrorDomains result when
+ * someone tries an incorrect domain calculation. NullDomain means a domain
+ * with nothing in it.
+ */
struct ErrorDomain
{
@@ -55,7 +62,10 @@
NullDomain(const NullDomain&) {}
};
-// The null-domain is contained by every domain.
+//@}
+
+/** The null-domain is contained by every domain.
+ */
template<class D>
bool contains(const NullDomain &, const D &)
diff -ur cvs/r2/src/Domain/Range.h pooma-doc/r2/src/Domain/Range.h
--- cvs/r2/src/Domain/Range.h 2003-03-18 21:11:44.000000000 +0100
+++ pooma-doc/r2/src/Domain/Range.h 2003-10-05 17:03:45.000000000 +0200
@@ -36,15 +36,17 @@
//////////////////////////////////////////////////////////////////////
-//-----------------------------------------------------------------------------
-// Overview:
-// Range is a general type of integer domain, which refers to a set of points
-// a, a+s, a+2s, ..., b. It has a run-time specified stride value s. It
-// is basically an array of Range<1> objects.
-//
-// Range defers most of its implementation to the Domain<DomainTraits<Range>>
-// base class.
-//-----------------------------------------------------------------------------
+/** @file
+ * @ingroup Domain
+ * @brief
+ * Range is a general type of integer domain, which refers to a set of points
+ * a, a+s, a+2s, ..., b.
+ *
+ * It has a run-time specified stride value s. It
+ * is basically an array of Range<1> objects.
+ * Range defers most of its implementation to the Domain<DomainTraits<Range>>
+ * base class.
+ */
//-----------------------------------------------------------------------------
// Typedefs:
@@ -72,7 +74,7 @@
//-----------------------------------------------------------------------------
//
-// Full Description of Range:
+/**
//
// Range<N> is a domain representing a set of N numeric sequences, one
// for each dimension N. The sequences have endpoints [a,b], with a stride
@@ -154,7 +156,7 @@
// after the general case that has different constructors.
//
// Range inherits much of its activity from Domain<DomainTraits<Range>>
-//
+*/
//-----------------------------------------------------------------------------
template<int Dim>
@@ -294,7 +296,7 @@
//-----------------------------------------------------------------------------
//
-// Full Description of Range<1>:
+/**
//
// Range<1> is a 1D specialization of Range<N>; for the 1D case,
// there are only a restricted set of constructors available.
@@ -306,7 +308,7 @@
// Range<1> a(m,n,s) - sets the Range to the sequence [m ... n], stride s
// Range<1> a(Domain d) : a Range copied from d, which must be a
// 1D domain object.
-//
+*/
//-----------------------------------------------------------------------------
template<>
diff -ur cvs/r2/src/Domain/RangeIterator.h
pooma-doc/r2/src/Domain/RangeIterator.h
--- cvs/r2/src/Domain/RangeIterator.h 2001-04-13 04:12:59.000000000 +0200
+++ pooma-doc/r2/src/Domain/RangeIterator.h 2003-01-16 20:46:35.000000000
+0100
@@ -34,11 +34,11 @@
// RangeIterator
//-----------------------------------------------------------------------------
-//-----------------------------------------------------------------------------
-// Overview:
-//
-// RangeIterator - Iterates through Range<1> points.
-//-----------------------------------------------------------------------------
+/** @file
+ * @ingroup Domain
+ * @brief
+ * RangeIterator - Iterates through Range<1> points.
+ */
//-----------------------------------------------------------------------------
// Includes:
@@ -58,12 +58,11 @@
//-----------------------------------------------------------------------------
//
-// Full Description:
-// RangeIterator
+/**
//
// A random access iterator class that iterates through all of the points
// of an Range<1>, returning ints when dereferenced.
-//
+*/
//-----------------------------------------------------------------------------
class RangeIterator
diff -ur cvs/r2/src/Domain/Region.h pooma-doc/r2/src/Domain/Region.h
--- cvs/r2/src/Domain/Region.h 2003-03-18 21:11:44.000000000 +0100
+++ pooma-doc/r2/src/Domain/Region.h 2003-10-05 17:03:45.000000000 +0200
@@ -33,23 +33,25 @@
#ifndef POOMA_DOMAIN_REGION_H
#define POOMA_DOMAIN_REGION_H
-//-----------------------------------------------------------------------------
-// Overview:
-// Region is a general type of continuous domain, which refers to all points
-// between two endpoints a and b.
-// It is basically an array of Region<1> objects.
-// It is templated on the number of dimensions, and the data type used to
-// store the values (generally double or float, but possibly any other type).
-// The macro POOMA_DEFAULT_POSITION_TYPE defines the type for a default
-// parameter value for the floating point type; if this macro is not defined,
-// double is used. So you can construct a Region<N>, and there will be a
-// default type T = double used. The user can override what the default
-// type should be by defining POOMA_DEFAULT_POSITION_TYPE when their
-// application is built.
-//
-// Region defers most of its implementation to the Domain<DomainTraits<Region>>
-// base class.
-//-----------------------------------------------------------------------------
+/** @file
+ * @ingroup Domain
+ * @brief
+ * Region is a general type of continuous domain, which refers to all points
+ * between two endpoints a and b.
+ *
+ * It is basically an array of Region<1> objects.
+ * It is templated on the number of dimensions, and the data type used to
+ * store the values (generally double or float, but possibly any other type).
+ * The macro POOMA_DEFAULT_POSITION_TYPE defines the type for a default
+ * parameter value for the floating point type; if this macro is not defined,
+ * double is used. So you can construct a Region<N>, and there will be a
+ * default type T = double used. The user can override what the default
+ * type should be by defining POOMA_DEFAULT_POSITION_TYPE when their
+ * application is built.
+ *
+ * Region defers most of its implementation to the Domain<DomainTraits<Region>>
+ * base class.
+ */
//-----------------------------------------------------------------------------
// Typedefs:
@@ -70,7 +72,7 @@
//-----------------------------------------------------------------------------
//
-// Full Description of Region:
+/**
//
// Region<N,T> is a domain representing a set of N continuous 1D regions, one
// for each dimension N. The regions have endpoints [a,b], and Region refers
@@ -162,7 +164,7 @@
// after the general case that has different constructors.
//
// Region inherits much of its activity from Domain<DomainTraits<Region>>
-//
+*/
//-----------------------------------------------------------------------------
template<int Dim, class T = POOMA_DEFAULT_POSITION_TYPE>
@@ -297,7 +299,7 @@
//-----------------------------------------------------------------------------
//
-// Full Description of Region<1>:
+/**
//
// Region<1> is a 1D specialization of Region<N>; for the 1D case,
// there are only a restricted set of constructors available.
@@ -314,7 +316,7 @@
// parameters (WHY???? Because The Standards Committee Is Evil), there
// is a version of the 1D specialization of Region for general type T, and
// a further specialization to 1D and type POOMA_DEFAULT_POSITION_TYPE.
-//
+*/
//-----------------------------------------------------------------------------
// specialization for 1D Region of type T
diff -ur cvs/r2/src/Domain/RightDomain.h pooma-doc/r2/src/Domain/RightDomain.h
--- cvs/r2/src/Domain/RightDomain.h 2003-03-18 21:11:44.000000000 +0100
+++ pooma-doc/r2/src/Domain/RightDomain.h 2003-10-05 17:03:45.000000000
+0200
@@ -37,18 +37,19 @@
//////////////////////////////////////////////////////////////////////
-//-----------------------------------------------------------------------------
-// Overview:
-//
-// RightDomain is one of the domain wildcards, which are used when constructing
-// other domains using specific combination rules. RightDomain means to use
-// the ending endpoint of the domain of a second 'reference' domain, with
-// a new user-provided left endpoint, when constructing a new
-// domain. It is also used when constructing new domains with no other
-// arguments to mean that the domain should not be initialized, which can
-// save considerable time in some circumstances.
-//
-//-----------------------------------------------------------------------------
+/** @file
+ * @ingroup Domain
+ * @brief
+ * RightDomain is one of the domain wildcards, which are used when constructing
+ * other domains using specific combination rules.
+ *
+ * RightDomain means to use
+ * the ending endpoint of the domain of a second 'reference' domain, with
+ * a new user-provided left endpoint, when constructing a new
+ * domain. It is also used when constructing new domains with no other
+ * arguments to mean that the domain should not be initialized, which can
+ * save considerable time in some circumstances.
+ */
//-----------------------------------------------------------------------------
// Typedefs:
@@ -69,7 +70,7 @@
//-----------------------------------------------------------------------------
//
-// Full Description of RightDomain:
+/**
//
// RightDomain is a special domain class which is used as a 'wildcard'.
// Wildcards are useful when constructing new domains based on some other
@@ -89,7 +90,7 @@
// dimensions should not be initialized, which can be helpful to avoid
// extra unneeded work when the domain will be filled with new values very
// soon.
-//
+*/
//-----------------------------------------------------------------------------
template<int Dim>
@@ -223,7 +224,7 @@
//-----------------------------------------------------------------------------
//
-// Full Description:
+/**
//
// DomainTraits<RightDomain<Dim>> provides traits info about RightDomain,
// which is one of the domain wildcards. It has a quite stripped-down
@@ -232,7 +233,7 @@
// dimension and the type of the wildcard, and an enum indicating that it is
// a wildcard. Also, getDomain returns a 1D element of the N-dimensional
// list of wildcards.
-//
+*/
//-----------------------------------------------------------------------------
template<int Dim>
Only in pooma-doc/r2/src/Domain: SCCS
diff -ur cvs/r2/src/Domain/Shrink.h pooma-doc/r2/src/Domain/Shrink.h
--- cvs/r2/src/Domain/Shrink.h 2000-07-25 03:08:39.000000000 +0200
+++ pooma-doc/r2/src/Domain/Shrink.h 2003-01-16 20:46:35.000000000 +0100
@@ -37,12 +37,15 @@
//////////////////////////////////////////////////////////////////////
-//-----------------------------------------------------------------------------
-// Overview:
-//
-// shrinkRight(Interval<Dim>,Loc<Dim>) returns an Interval<Dim> which is
-// Loc<Dim> shorter in each direction.
-//-----------------------------------------------------------------------------
+/** @file
+ * @ingroup Domain
+ * @brief
+ * Interval<Dim> shrinking and growing on either side by int or Loc<Dim>.
+ *
+ * Examples:
+ * - shrinkRight(Interval<1>(0, 4), 1) == Interval<1>(0, 3)
+ * - growLeft(Interval<1>(0, 4), 1) == Interval<1>(-1, 4)
+ */
//-----------------------------------------------------------------------------
// Typedefs:
@@ -59,12 +62,8 @@
// Forward Declarations:
//-----------------------------------------------------------------------------
-//-----------------------------------------------------------------------------
-//
-// Full Description:
-//
-//-----------------------------------------------------------------------------
+/// Deprecated. Use shrinkRight().
template<int Dim>
Interval<Dim> &
shrinkRightInPlace(Interval<Dim> &dom, const Loc<Dim> &s)
@@ -78,6 +77,7 @@
return dom;
}
+/// Deprecated. Use shrinkRight().
template<int Dim>
Interval<Dim> &
shrinkRightInPlace(Interval<Dim> &dom, int s)
@@ -91,6 +91,7 @@
return dom;
}
+/// Deprecated. Use growRight().
template<int Dim>
Interval<Dim> &
growRightInPlace(Interval<Dim> &dom, const Loc<Dim> &s)
@@ -104,6 +105,7 @@
return dom;
}
+/// Deprecated. Use growRight().
template<int Dim>
Interval<Dim> &
growRightInPlace(Interval<Dim> &dom, int s)
@@ -117,6 +119,7 @@
return dom;
}
+/// Shrinks the Interval dom from the right by s[i] in direction i.
template<int Dim>
inline Interval<Dim>
shrinkRight(const Interval<Dim> &dom, const Loc<Dim> &s)
@@ -125,6 +128,7 @@
return shrinkRightInPlace(ret, s);
}
+/// Shrinks the Interval dom from the right by s in every direction.
template<int Dim>
inline Interval<Dim>
shrinkRight(const Interval<Dim> &dom, int s)
@@ -133,6 +137,7 @@
return shrinkRightInPlace(ret, s);
}
+/// Grows the Interval dom to the right by s[i] in direction i.
template<int Dim>
inline Interval<Dim>
growRight(const Interval<Dim> &dom, const Loc<Dim> &s)
@@ -141,6 +146,7 @@
return growRightInPlace(ret, s);
}
+/// Grows the Interval dom to the right by s in every direction.
template<int Dim>
inline Interval<Dim>
growRight(const Interval<Dim> &dom, int s)
diff -ur cvs/r2/src/Domain/SliceDomain.h pooma-doc/r2/src/Domain/SliceDomain.h
--- cvs/r2/src/Domain/SliceDomain.h 2001-04-13 04:12:59.000000000 +0200
+++ pooma-doc/r2/src/Domain/SliceDomain.h 2003-01-16 20:46:35.000000000
+0100
@@ -36,21 +36,24 @@
//////////////////////////////////////////////////////////////////////
-//-----------------------------------------------------------------------------
-// Overview:
-// SliceDomain is a base class for all sliced domain objects. A sliced
-// domain stores two pieces of information:
-// 1. A "total domain" of dimension TotalDim
-// 2. A "slice domain" of dimension SliceDim, with SliceDim < TotalDim.
-// SliceDomain stores both domains, and provides accessors to get references
-// to them. It does not have the full interface as regular domains, you
-// must get a reference to the relevant domain (total or slice) and then
-// use that as normal. Unlike the regular Domain class, SliceDomain does
-// not have or need any 1D specializations, or any base class.
-// SliceDomain is templated on the DomainTraits<> class providing the
-// traits for the SliceDomain derived class. It does not have a Dim
-// template parameter as Domain does.
-//-----------------------------------------------------------------------------
+/** @file
+ * @ingroup Domain
+ * @brief
+ * SliceDomain is a base class for all sliced domain objects.
+ *
+ * A sliced
+ * domain stores two pieces of information:
+ * 1. A "total domain" of dimension TotalDim
+ * 2. A "slice domain" of dimension SliceDim, with SliceDim < TotalDim.
+ * SliceDomain stores both domains, and provides accessors to get references
+ * to them. It does not have the full interface as regular domains, you
+ * must get a reference to the relevant domain (total or slice) and then
+ * use that as normal. Unlike the regular Domain class, SliceDomain does
+ * not have or need any 1D specializations, or any base class.
+ * SliceDomain is templated on the DomainTraits<> class providing the
+ * traits for the SliceDomain derived class. It does not have a Dim
+ * template parameter as Domain does.
+ */
//-----------------------------------------------------------------------------
// Typedefs:
@@ -74,7 +77,7 @@
//-----------------------------------------------------------------------------
//
-// Full Description:
+/**
//
// SliceDomain<DT> provides the bulk of the public interface for all
// sliced domain objects. The template parameter should be DomainTraits<DT>,
@@ -112,7 +115,7 @@
// SliceDomain_t &sliceDomain();
// const TotalDomain_t &totalDomain() const;
// TotalDomain_t &totalDomain();
-//
+*/
//-----------------------------------------------------------------------------
template<class DT>
diff -ur cvs/r2/src/Domain/SliceInterval.h
pooma-doc/r2/src/Domain/SliceInterval.h
--- cvs/r2/src/Domain/SliceInterval.h 2001-04-13 04:12:59.000000000 +0200
+++ pooma-doc/r2/src/Domain/SliceInterval.h 2003-01-16 20:46:35.000000000
+0100
@@ -36,22 +36,22 @@
//////////////////////////////////////////////////////////////////////
-//-----------------------------------------------------------------------------
-// Overview:
-//
-// Slice domain objects are domains which have N dimensions worth of 1D
-// domain data, but really represent the result of taking an M-dimensional
-// slice (M < N) of another N dimensional domain.
-//
-// SliceInterval<N,M> is is basically an array of N Interval<1> objects,
-// but it also knows that only M of these are full domains, and that N-M
-// domains are actually referring to single points. You can retrieve all
-// N 1D domains as a normal Interval<N> object, or the smaller slice domain
-// as an Interval<M> object.
-//
-// SliceInterval defers most of its implementation to the
-// SliceDomain<DomainTraits<SliceInterval>> base class.
-//-----------------------------------------------------------------------------
+/** @file
+ * @ingroup Domain
+ * @brief
+ * Slice domain objects are domains which have N dimensions worth of 1D
+ * domain data, but really represent the result of taking an M-dimensional
+ * slice (M < N) of another N dimensional domain.
+ *
+ * SliceInterval<N,M> is is basically an array of N Interval<1> objects,
+ * but it also knows that only M of these are full domains, and that N-M
+ * domains are actually referring to single points. You can retrieve all
+ * N 1D domains as a normal Interval<N> object, or the smaller slice domain
+ * as an Interval<M> object.
+ *
+ * SliceInterval defers most of its implementation to the
+ * SliceDomain<DomainTraits<SliceInterval>> base class.
+ */
//-----------------------------------------------------------------------------
// Typedefs:
@@ -73,7 +73,7 @@
//-----------------------------------------------------------------------------
//
-// Full Description of SliceInterval:
+/**
//
// SliceInterval<N,M> is a special form of domain object which stores a
// total domain and a slice domain, both as Interval<N> or <M> objects.
@@ -101,7 +101,7 @@
// retrieve a reference to the relevant domain, and then use that domain
// as normal. getTotalDomain() returns an Interval<N> ref, while
// getSliceDomain() returns an Interval<M> ref.
-//
+*/
//-----------------------------------------------------------------------------
template<int Dim, int SliceDim>
diff -ur cvs/r2/src/Domain/SliceRange.h pooma-doc/r2/src/Domain/SliceRange.h
--- cvs/r2/src/Domain/SliceRange.h 2001-04-13 04:12:59.000000000 +0200
+++ pooma-doc/r2/src/Domain/SliceRange.h 2003-01-16 20:46:35.000000000
+0100
@@ -36,22 +36,22 @@
//////////////////////////////////////////////////////////////////////
-//-----------------------------------------------------------------------------
-// Overview:
-//
-// Slice domain objects are domains which have N dimensions worth of 1D
-// domain data, but really represent the result of taking an M-dimensional
-// slice (M < N) of another N dimensional domain.
-//
-// SliceRange<N,M> is is basically an array of N Range<1> objects,
-// but it also knows that only M of these are full domains, and that N-M
-// domains are actually referring to single points. You can retrieve all
-// N 1D domains as a normal Range<N> object, or the smaller slice domain
-// as a Range<M> object.
-//
-// SliceRange defers most of its implementation to the
-// SliceDomain<DomainTraits<SliceRange>> base class.
-//-----------------------------------------------------------------------------
+/** @file
+ * @ingroup Domain
+ * @brief
+ * Slice domain objects are domains which have N dimensions worth of 1D
+ * domain data, but really represent the result of taking an M-dimensional
+ * slice (M < N) of another N dimensional domain.
+ *
+ * SliceRange<N,M> is is basically an array of N Range<1> objects,
+ * but it also knows that only M of these are full domains, and that N-M
+ * domains are actually referring to single points. You can retrieve all
+ * N 1D domains as a normal Range<N> object, or the smaller slice domain
+ * as a Range<M> object.
+ *
+ * SliceRange defers most of its implementation to the
+ * SliceDomain<DomainTraits<SliceRange>> base class.
+ */
//-----------------------------------------------------------------------------
// Typedefs:
@@ -72,7 +72,7 @@
//-----------------------------------------------------------------------------
//
-// Full Description of SliceRange:
+/**
//
// SliceRange<N,M> is a special form of domain object which stores a
// total domain and a slice domain, both as Range<N> or <M> objects.
@@ -100,7 +100,7 @@
// retrieve a reference to the relevant domain, and then use that domain
// as normal. getTotalDomain() returns a Range<N> ref, while
// getSliceDomain() returns a Range<M> ref.
-//
+*/
//-----------------------------------------------------------------------------
template<int Dim, int SliceDim>
diff -ur cvs/r2/src/Domain/Split.h pooma-doc/r2/src/Domain/Split.h
--- cvs/r2/src/Domain/Split.h 2003-03-18 21:11:44.000000000 +0100
+++ pooma-doc/r2/src/Domain/Split.h 2003-10-05 17:03:45.000000000 +0200
@@ -39,14 +39,16 @@
//////////////////////////////////////////////////////////////////////
-//-----------------------------------------------------------------------------
-// Overview:
-// void split(domain,domain,domain) is a global function which splits the
-// first argument into two separate domains, roughly in the moddle. If
-// the first argument has zero length, this does nothing. If the first
-// argument has a length of one, the second argument is a copy of the
-// first, and the second is set to be empty.
-//-----------------------------------------------------------------------------
+/** @file
+ * @ingroup Domain
+ * @brief
+ * void split(domain,domain,domain) is a global function which splits the
+ * first argument into two separate domains, roughly in the moddle.
+ *
+ * If the first argument has zero length, this does nothing. If the first
+ * argument has a length of one, the second argument is a copy of the
+ * first, and the second is set to be empty.
+ */
//-----------------------------------------------------------------------------
// Typedefs:
@@ -67,19 +69,19 @@
//-----------------------------------------------------------------------------
//
-// Full Description of SplitDomainSingle:
+/**
//
// SplitDomainSingle<T,Dim,bool strided>::split(a,b,c) splits just the
// Dim dimension of the first argument into the second and third argument.
// It is specialized on the third parameter indicating whether the
// domain has unit stride or not, and whether the type is int or not.
-//
+*/
//-----------------------------------------------------------------------------
-//
+/**
// The default (unit-stride) version of SplitDomainSingle, which assumes
// that the domains have unit stride.
-//
+*/
template<class T, int Dim, bool strided>
struct SplitDomainSingle {
@@ -130,9 +132,9 @@
static void split(const T &a, T &b, T &c) { split(a, Dim-1, b, c); }
};
-//
+/**
// The non-unit-stride version of SplitDomainSingle.
-//
+*/
template<class T, int Dim>
struct SplitDomainSingle<T,Dim,true> {
@@ -185,10 +187,10 @@
static void split(const T &a, T &b, T &c) { split(a, Dim-1, b, c); }
};
-//
+/**
// Special version of SplitDomainSingle for int's, which must be
// handled uniquely.
-//
+*/
template<int Dim, bool strided>
struct SplitDomainSingle<int,Dim,strided> {
@@ -210,7 +212,7 @@
//-----------------------------------------------------------------------------
//
-// Full Description of SplitDomain:
+/**
//
// SplitDomain implements a basic template meta-program to split
// each dimension separately of the multidimensional domain.
@@ -219,7 +221,7 @@
// A general version of SplitDomain is defined, to split the
// domain in the 'Dim' dimension, and then a specialization is provided
// for Dim==1 that stops the metaprogram recursion.
-//
+*/
//-----------------------------------------------------------------------------
template<class T, int Dim>
@@ -276,7 +278,7 @@
//-----------------------------------------------------------------------------
//
-// Full Description of split:
+/**
//
// void split(domain,domain,domain) is a global function which splits the
// first argument into two separate domains, roughly in the middle. If
@@ -284,13 +286,9 @@
// argument has a length of one, the second argument is a copy of the
// first, and the second is set to be empty.
//
-// void split(domain,axis,domain,domain) is a global function which splits
-// the first argument into two separate domains just along the Nth axis instead
-// of along all axes. Otherwise it is the same as the other global split.
-//
// The implementation of split is deferred to the SplitDomain
// struct, which performs the split for each dimension.
-//
+*/
//-----------------------------------------------------------------------------
template<class T>
@@ -299,6 +297,9 @@
SplitDomain<T,DomainTraits<T>::dimensions>::split(a, b, c);
}
+/// void split(domain,axis,domain,domain) is a global function which splits
+/// the first argument into two separate domains just along the Nth axis
instead
+/// of along all axes. Otherwise it is the same as the other global split.
template<class T>
inline void split(const T &a, int axis, T &b, T &c)
@@ -306,6 +307,10 @@
SplitDomain<T,DomainTraits<T>::dimensions>::split(a, axis, b, c);
}
+/// void split(domain,axis,leftLength,domain,domain) is a global function which
+/// splits the first argument into two separate domains just along the Nth axis
+/// with specified size of the left part of the domain.
+/// Otherwise it is the same as the other global split.
template<class T>
inline void split(const T &a, int axis, int leftLength, T &b, T &c)
diff -ur cvs/r2/src/Domain/Touches.h pooma-doc/r2/src/Domain/Touches.h
--- cvs/r2/src/Domain/Touches.h 2003-03-18 21:11:44.000000000 +0100
+++ pooma-doc/r2/src/Domain/Touches.h 2003-10-05 17:03:45.000000000 +0200
@@ -39,21 +39,24 @@
//////////////////////////////////////////////////////////////////////
-//-----------------------------------------------------------------------------
-// Overview:
-// bool touches(domain,domain) is a global function which determines if
-// two domains d1 and d2 overlap in any way. 'Overlap' means that there is
-// at least one point which resides in both domains. If this is the case,
-// it returns true, otherwise false.
-//
-// touches uses a partially-specialized struct 'TouchesDomain' to do the work;
-// TouchesDomain implements a template metaprogram to check that each dimension
-// touches and and's the results together. TouchesDomain, in turn, uses
-// TouchesDomainSingle to perform the touches calculation for two 1D domains,
-// with specialization for the case where one or both of the domains have
-// unit stride, and for the case where neither have unit stride (which is
-// a much more complicated computation).
-//-----------------------------------------------------------------------------
+/** @file
+ * @ingroup Domain
+ * @brief
+ * bool touches(domain,domain) is a global function which determines if
+ * two domains d1 and d2 overlap in any way.
+ *
+ * 'Overlap' means that there is
+ * at least one point which resides in both domains. If this is the case,
+ * it returns true, otherwise false.
+ *
+ * touches uses a partially-specialized struct 'TouchesDomain' to do the work;
+ * TouchesDomain implements a template metaprogram to check that each dimension
+ * touches and and's the results together. TouchesDomain, in turn, uses
+ * TouchesDomainSingle to perform the touches calculation for two 1D domains,
+ * with specialization for the case where one or both of the domains have
+ * unit stride, and for the case where neither have unit stride (which is
+ * a much more complicated computation).
+ */
//-----------------------------------------------------------------------------
// Typedefs:
@@ -74,7 +77,7 @@
//-----------------------------------------------------------------------------
//
-// Full Description of TouchesDomainSingle:
+/**
//
// TouchesDomainSingle<T1,T2,bool strided>::touches(a,b) compares two
// domains a and b of type T1 and T2, and returns true if they touch.
@@ -90,13 +93,13 @@
// they will not have any points in common due to the
// striding. We only do this long calculation when
// absolutely necessary.
-//
+*/
//-----------------------------------------------------------------------------
-//
+/**
// The default (unit-stride) version of TouchesDomainSingle, which assumes
// that both arguments to 'touches' are 1D domains with unit stride
-//
+*/
template<class T1, class T2, bool strided>
struct TouchesDomainSingle {
@@ -105,10 +108,10 @@
}
};
-//
+/**
// The non-unit-stride version of TouchesDomainSingle, which does extra
// work for the case where a and b do not have unit stride.
-//
+*/
template<class T1, class T2>
struct TouchesDomainSingle<T1,T2,true> {
@@ -138,7 +141,7 @@
//-----------------------------------------------------------------------------
//
-// Full Description of TouchesDomain:
+/**
//
// TouchesDomain implements a basic template meta-program to
// compare each dimension separately of the multidimensional domains for
@@ -147,7 +150,7 @@
// or not. A general version of TouchesDomain is defined, to compare the
// domains in the 'Dim' dimension, and then a specialization is provided
// for Dim==1 that stops the metaprogram recursion.
-//
+*/
//-----------------------------------------------------------------------------
template<class T1, class T2, int Dim>
@@ -193,7 +196,7 @@
//-----------------------------------------------------------------------------
//
-// Full Description of touches:
+/**
//
// bool touches(domain1, domain2) is one of the domain calculus routines
// used to analyze domains to determine their relative characteristics. It
@@ -207,7 +210,7 @@
// The implementation of touches is deferred to the TouchesDomain
// struct, which performs the touches comparison for each dimension and and's
// the results together.
-//
+*/
//-----------------------------------------------------------------------------
template<class T1, class T2, int Dim1, int Dim2>
Only in cvs/r2/src/Domain/tests: CVS
Only in cvs/r2/src/Domain/tests: LINUXgcc
Only in cvs/r2/src/Domain/tests: LINUXgcc295
Only in cvs/r2/src/Domain/tests: LINUXgcc32
Only in cvs/r2/src/Domain/tests: LINUXgcc32g
Only in pooma-doc/r2/src/Domain/tests: SCCS
| [Prev in Thread] |
Current Thread |
[Next in Thread] |
- [PATCH] Convert Domain/ documentation to doxygen recognizable format,
Richard Guenther <=