FreePOOMA  2.4.1
Classes | Defines | Functions
DomainBase.h File Reference

DomainBase is a common base class for all domain objects. More...

#include "Domain/DomainArithOpsTraits.h"
#include "Domain/DomainIterator.h"
#include "Domain/DomainBlockIterator.h"
#include "Domain/DomainTraits.h"
#include "Utilities/NoInit.h"
#include "Utilities/PAssert.h"
#include <iosfwd>
Include dependency graph for DomainBase.h:
This graph shows which files directly or indirectly include this file:

Classes

class  DomainBase< DT >
 DomainBaseis the common base class for all Domain<Dim, DT> objects, regardless of the value of Dim. More...
struct  DomPair< T1, T2, SV >
struct  DomPair< T1, T2, false >

Defines

#define POOMA_DOMAIN_OPERATOR_SINGLE(OPFUNCTION, OP, LHSTYPE)
#define POOMA_DOMAIN_OPERATOR(OPFUNCTION, OP)
#define POOMA_DOMAIN_ARITH_SINGLE(OPFUNCTION, OP, RETTYPE, LHSTYPE)
#define POOMA_DOMAIN_ARITH(OPFUNCTION, OP, RETTYPE)

Functions

template<class T1 , class T2 >
DomainArithOpsTraits< typename
T1::Domain_t, typename
T2::Domain_t >::AddResult_t 
operator+ (const DomainBase< T1 > &d1, const DomainBase< T2 > &d2)
template<class T1 , class T2 >
DomainArithOpsTraits< typename
T1::Domain_t, typename
T2::Domain_t >::SubResult_t 
operator- (const DomainBase< T1 > &d1, const DomainBase< T2 > &d2)
template<class T1 , class T2 >
DomainArithOpsTraits< typename
T1::Domain_t, typename
T2::Domain_t >::MultResult_t 
operator* (const DomainBase< T1 > &d1, const DomainBase< T2 > &d2)
template<class T1 , class T2 >
DomainArithOpsTraits< typename
T1::Domain_t, typename
T2::Domain_t >::MultResult_t 
operator/ (const DomainBase< T1 > &d1, const DomainBase< T2 > &d2)
template<class D , class V >
void DomainToVector (const D &dom, V &vec)
template<class V , class D >
void VectorToDomain (const V &vec, D &dom)
template<class DT >
std::ostream & operator<< (std::ostream &o, const DomainBase< DT > &dbase)

Detailed Description

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.


Define Documentation

#define POOMA_DOMAIN_OPERATOR_SINGLE (   OPFUNCTION,
  OP,
  LHSTYPE 
)
Value:
template<class T>                \
inline bool                   \
OPFUNCTION(LHSTYPE d1, const DomainBase<T> &d2) {     \
  return (d2.unwrap() OP d1);             \
}
#define POOMA_DOMAIN_OPERATOR (   OPFUNCTION,
  OP 
)
Value:
POOMA_DOMAIN_OPERATOR_SINGLE(OPFUNCTION, OP, char)    \
POOMA_DOMAIN_OPERATOR_SINGLE(OPFUNCTION, OP, unsigned char) \
POOMA_DOMAIN_OPERATOR_SINGLE(OPFUNCTION, OP, short)      \
POOMA_DOMAIN_OPERATOR_SINGLE(OPFUNCTION, OP, unsigned short)   \
POOMA_DOMAIN_OPERATOR_SINGLE(OPFUNCTION, OP, int)     \
POOMA_DOMAIN_OPERATOR_SINGLE(OPFUNCTION, OP, unsigned int)  \
POOMA_DOMAIN_OPERATOR_SINGLE(OPFUNCTION, OP, long)    \
POOMA_DOMAIN_OPERATOR_SINGLE(OPFUNCTION, OP, unsigned long) \
POOMA_DOMAIN_OPERATOR_SINGLE(OPFUNCTION, OP, float)      \
POOMA_DOMAIN_OPERATOR_SINGLE(OPFUNCTION, OP, double)
#define POOMA_DOMAIN_ARITH_SINGLE (   OPFUNCTION,
  OP,
  RETTYPE,
  LHSTYPE 
)
Value:
template<class T>                   \
inline typename T::RETTYPE                \
OPFUNCTION(const DomainBase<T> &d1, LHSTYPE d2) {        \
  typename T::RETTYPE retval(d1.unwrap());            \
  return (retval OP d2);                  \
}                          \
template<class T>                   \
inline typename T::RETTYPE                \
OPFUNCTION(LHSTYPE d1, const DomainBase<T> &d2) {        \
  typename T::RETTYPE retval(d2.unwrap());            \
  return (retval OP d1);                  \
}
#define POOMA_DOMAIN_ARITH (   OPFUNCTION,
  OP,
  RETTYPE 
)
Value:
POOMA_DOMAIN_ARITH_SINGLE(OPFUNCTION, OP, RETTYPE, char)    \
POOMA_DOMAIN_ARITH_SINGLE(OPFUNCTION, OP, RETTYPE, unsigned char) \
POOMA_DOMAIN_ARITH_SINGLE(OPFUNCTION, OP, RETTYPE, short)      \
POOMA_DOMAIN_ARITH_SINGLE(OPFUNCTION, OP, RETTYPE, unsigned short)   \
POOMA_DOMAIN_ARITH_SINGLE(OPFUNCTION, OP, RETTYPE, int)             \
POOMA_DOMAIN_ARITH_SINGLE(OPFUNCTION, OP, RETTYPE, unsigned int)  \
POOMA_DOMAIN_ARITH_SINGLE(OPFUNCTION, OP, RETTYPE, long)    \
POOMA_DOMAIN_ARITH_SINGLE(OPFUNCTION, OP, RETTYPE, unsigned long) \
POOMA_DOMAIN_ARITH_SINGLE(OPFUNCTION, OP, RETTYPE, float)      \
POOMA_DOMAIN_ARITH_SINGLE(OPFUNCTION, OP, RETTYPE, double)

Function Documentation

template<class T1 , class T2 >
DomainArithOpsTraits<typename T1::Domain_t, typename T2::Domain_t>::AddResult_t operator+ ( const DomainBase< T1 > &  d1,
const DomainBase< T2 > &  d2 
) [inline]
template<class T1 , class T2 >
DomainArithOpsTraits<typename T1::Domain_t, typename T2::Domain_t>::SubResult_t operator- ( const DomainBase< T1 > &  d1,
const DomainBase< T2 > &  d2 
) [inline]
template<class T1 , class T2 >
DomainArithOpsTraits<typename T1::Domain_t, typename T2::Domain_t>::MultResult_t operator* ( const DomainBase< T1 > &  d1,
const DomainBase< T2 > &  d2 
) [inline]
template<class T1 , class T2 >
DomainArithOpsTraits<typename T1::Domain_t, typename T2::Domain_t>::MultResult_t operator/ ( const DomainBase< T1 > &  d1,
const DomainBase< T2 > &  d2 
) [inline]
template<class D , class V >
void DomainToVector ( const D &  dom,
V &  vec 
) [inline]
template<class V , class D >
void VectorToDomain ( const V &  vec,
D &  dom 
) [inline]
template<class DT >
std::ostream& operator<< ( std::ostream &  o,
const DomainBase< DT > &  dbase 
)