FreePOOMA  2.4.1
Classes | Defines
NewDomain.h File Reference

A set of simple structs which tell how to combine different Domain objects together. More...

#include "Domain/DomainTraits.h"
#include "Utilities/PAssert.h"
Include dependency graph for NewDomain.h:
This graph shows which files directly or indirectly include this file:

Classes

struct  CombineDomain< RT, CT, DS >
 CombineDomain is a utility class used only by the 'fill*' methods of NewDomain2 ... More...
struct  CombineSliceDomainWC< RT, UT, CT, DS, SliceDS, incl, wc >
 the general version of CombineSliceDomainWC ... More...
struct  CombineSliceDomainWC< RT, UT, CT, DS, SliceDS, true, false >
 specialization of CombineSliceDomainWC in which we fill in slice domain values and full domain values, but without using wildcards More...
struct  CombineSliceDomainWC< RT, UT, CT, DS, SliceDS, false, true >
 specialization of CombineSliceDomainWC in which we only fill in total domain values, using wildcards More...
struct  CombineSliceDomainWC< RT, UT, CT, DS, SliceDS, true, true >
 specialization of CombineSliceDomainWC in which we fill in slice domain values and full domain values, using wildcards More...
struct  CombineSliceDomain< RT, UT, CT, DS, SliceDS, incl >
 the general version of CombineSliceDomain ... More...
struct  NewDomain2Base< T1, T2, TCombine, TSCombine >
struct  AddNewDomain2Dimensions< T1, T2 >
class  NewDomain2< T1, T2 >
struct  NewDomain2< Grid< D >, IndirectionList< int > >
struct  NewDomain2< IndirectionList< int >, Grid< D > >
struct  NewDomain2< Loc< D1 >, Loc< D2 > >
struct  NewDomainNBase< ND, T >
struct  NewDomain1< T1 >
struct  NewDomain3< T1, T2, T3 >
struct  NewDomain4< T1, T2, T3, T4 >
struct  NewDomain5< T1, T2, T3, T4, T5 >
struct  NewDomain6< T1, T2, T3, T4, T5, T6 >
struct  NewDomain7< T1, T2, T3, T4, T5, T6, T7 >
struct  TemporaryNewDomain1< Domain, Sub >
struct  TemporaryNewDomain1< Domain, AllDomain< N > >

Defines

#define POOMA_NEWDOMAIN_SAME_SCALAR(DOM, SLICEDOM, S)
#define POOMA_NEWDOMAIN_SAME(DOM, SLICEDOM)
#define POOMA_NEWDOMAIN_OTHER(DOM1, DOM2)
#define POOMA_NEWDOMAIN_SLICE_SAME_SCALAR(SLICEDOM, S)
#define POOMA_NEWDOMAIN_SLICE_SAME(SLICEDOM)
#define POOMA_NEWDOMAIN_SLICE_OTHER(DOM1, DOM2, SLICEDOM)
#define POOMA_NEWDOMAIN_CONTINUOUS_SAME(DOM)
#define POOMA_NEWDOMAIN_CONTINUOUS_SCALAR(DOM, S)
#define POOMA_NEWDOMAIN_CONTINUOUS_OTHER(DOM1, DOM2)
#define POOMA_NEWDOMAIN_JUST_SCALAR_SAME(S, DOM)
#define POOMA_NEWDOMAIN_JUST_SCALAR_OTHER(S1, S2, DOM, S3)
#define POOMA_NEWDOMAIN_JUST_SCALAR_DOMAIN(S, DOM1, DOM2)

Detailed Description

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:

similarly for NewDomain1, and NewDomain3 ... NewDomain7


Define Documentation

#define POOMA_NEWDOMAIN_SAME_SCALAR (   DOM,
  SLICEDOM,
 
)
Value:
template <int D>                       \
struct NewDomain2< DOM<D>, S >                     \
  : public NewDomain2Base< DOM<D>, S, DOM<D+1>, SLICEDOM<D+1,D> > { };     \
template <int D>                       \
struct NewDomain2< S, DOM<D> >                     \
  : public NewDomain2Base< S, DOM<D>, DOM<D+1>, SLICEDOM<D+1,D> > { };     \
template <int D>                       \
struct NewDomain2< DOM<D>, unsigned S >                  \
  : public NewDomain2Base< DOM<D>, unsigned S, DOM<D+1>, SLICEDOM<D+1,D> > \
{ };                                                                       \
template <int D>                       \
struct NewDomain2< unsigned S, DOM<D> >                  \
  : public NewDomain2Base< unsigned S, DOM<D>, DOM<D+1>, SLICEDOM<D+1,D> > \
{ };
#define POOMA_NEWDOMAIN_SAME (   DOM,
  SLICEDOM 
)
Value:
template <int D1, int D2>                    \
struct NewDomain2< DOM<D1>, DOM<D2> >                 \
  : public NewDomain2Base< DOM<D1>, DOM<D2>, DOM<D1+D2>, DOM<D1+D2> > { }; \
template <int D1, int D2>                    \
struct NewDomain2< DOM<D1>, Loc<D2> >                 \
  : public NewDomain2Base< DOM<D1>, Loc<D2>, DOM<D1+D2>,                   \
                           SLICEDOM<D1+D2,D1> > { };                       \
template <int D1, int D2>                    \
struct NewDomain2< Loc<D2>, DOM<D1> >                 \
  : public NewDomain2Base< Loc<D2>, DOM<D1>, DOM<D1+D2>,                   \
                           SLICEDOM<D1+D2,D1> > { };                       \
POOMA_NEWDOMAIN_SAME_SCALAR(DOM,SLICEDOM,char)              \
POOMA_NEWDOMAIN_SAME_SCALAR(DOM,SLICEDOM,short)                  \
POOMA_NEWDOMAIN_SAME_SCALAR(DOM,SLICEDOM,int)               \
POOMA_NEWDOMAIN_SAME_SCALAR(DOM,SLICEDOM,long)
#define POOMA_NEWDOMAIN_OTHER (   DOM1,
  DOM2 
)
Value:
template <int D1, int D2>                    \
struct NewDomain2< DOM1<D1>, DOM2<D2> >                  \
  : public NewDomain2Base< DOM1<D1>, DOM2<D2>, DOM1<D1+D2>, DOM1<D1+D2> >  \
{ };                                                                       \
template <int D1, int D2>                    \
struct NewDomain2< DOM2<D1>, DOM1<D2> >                  \
  : public NewDomain2Base< DOM2<D1>, DOM1<D2>, DOM1<D1+D2>, DOM1<D1+D2> >  \
{ };
#define POOMA_NEWDOMAIN_SLICE_SAME_SCALAR (   SLICEDOM,
 
)
Value:
template <int D1, int DS1>                   \
struct NewDomain2< SLICEDOM<D1,DS1>, S >              \
  : public NewDomain2Base< SLICEDOM<D1,DS1>, S ,SLICEDOM<D1+1,DS1>,     \
                           SLICEDOM<D1+1,DS1> > { };           \
template <int D1, int DS1>                   \
struct NewDomain2< SLICEDOM<D1,DS1>, unsigned S >           \
  : public NewDomain2Base< SLICEDOM<D1,DS1>, unsigned S,                   \
                           SLICEDOM<D1+1,DS1>, SLICEDOM<D1+1,DS1> > { };   \
template <int D1, int DS1>                   \
struct NewDomain2< S, SLICEDOM<D1,DS1> >              \
  : public NewDomain2Base< S, SLICEDOM<D1,DS1>, SLICEDOM<D1+1,DS1>,     \
                           SLICEDOM<D1+1,DS1> > { };           \
template <int D1, int DS1>                   \
struct NewDomain2< unsigned S, SLICEDOM<D1,DS1> >           \
  : public NewDomain2Base< unsigned S, SLICEDOM<D1,DS1>,                   \
                           SLICEDOM<D1+1,DS1>, SLICEDOM<D1+1,DS1> > { };
#define POOMA_NEWDOMAIN_SLICE_SAME (   SLICEDOM)
Value:
template <int D1, int DS1, int D2>                 \
struct NewDomain2< SLICEDOM<D1,DS1>, Loc<D2> >              \
  : public NewDomain2Base< SLICEDOM<D1,DS1>, Loc<D2>, SLICEDOM<D1+D2,DS1>, \
                           SLICEDOM<D1+D2,DS1> > { };          \
template <int D1, int DS1, int D2>                 \
struct NewDomain2< Loc<D2>, SLICEDOM<D1,DS1> >              \
  : public NewDomain2Base< Loc<D2>, SLICEDOM<D1,DS1>, SLICEDOM<D1+D2,DS1>, \
                           SLICEDOM<D1+D2,DS1> > { };          \
POOMA_NEWDOMAIN_SLICE_SAME_SCALAR(SLICEDOM,char)            \
POOMA_NEWDOMAIN_SLICE_SAME_SCALAR(SLICEDOM,short)           \
POOMA_NEWDOMAIN_SLICE_SAME_SCALAR(SLICEDOM,int)                  \
POOMA_NEWDOMAIN_SLICE_SAME_SCALAR(SLICEDOM,long)
#define POOMA_NEWDOMAIN_SLICE_OTHER (   DOM1,
  DOM2,
  SLICEDOM 
)
Value:
template <int D1, int DS1, int D2>                      \
struct NewDomain2< DOM1<D1,DS1>, DOM2<D2> >                   \
  : public NewDomain2Base< DOM1<D1,DS1>, DOM2<D2>, SLICEDOM<D1+D2,DS1+D2>, \
            SLICEDOM<D1+D2,DS1+D2> > { };       \
template <int D1, int DS1, int D2>                      \
struct NewDomain2< DOM2<D2>, DOM1<D1,DS1> >                   \
  : public NewDomain2Base< DOM2<D2>, DOM1<D1,DS1>, SLICEDOM<D1+D2,DS1+D2>, \
            SLICEDOM<D1+D2,DS1+D2> > { };
Value:
template <int D1, class T1, int D2, class T2>                    \
struct NewDomain2< DOM<D1,T1>, DOM<D2,T2> >                   \
  : public NewDomain2Base< DOM<D1,T1>, DOM<D2,T2>, DOM<D1+D2,T1>,    \
                           DOM<D1+D2,T1> > { };
#define POOMA_NEWDOMAIN_CONTINUOUS_SCALAR (   DOM,
 
)
Value:
template <int D1, class T1>                     \
struct NewDomain2< DOM<D1,T1>, S >                 \
  : public NewDomain2Base< DOM<D1,T1>, S, DOM<D1+1,T1>, DOM<D1+1,T1> >     \
{ };                                                                     \
template <int D1, class T1>                     \
struct NewDomain2< S, DOM<D1,T1> >                 \
  : public NewDomain2Base< S, DOM<D1,T1>, DOM<D1+1,T1>, DOM<D1+1,T1> >     \
{ };
#define POOMA_NEWDOMAIN_CONTINUOUS_OTHER (   DOM1,
  DOM2 
)
Value:
template <int D1, class T1, int D2>                     \
struct NewDomain2< DOM1<D1,T1>, DOM2<D2> >                    \
  : public NewDomain2Base< DOM1<D1,T1>, DOM2<D2>, DOM1<D1+D2,T1>,    \
                           DOM1<D1+D2,T1> > { };            \
template <int D1, class T1, int D2>                     \
struct NewDomain2< DOM2<D2>, DOM1<D1,T1> >                    \
  : public NewDomain2Base< DOM2<D2>, DOM1<D1,T1>, DOM1<D1+D2,T1>,    \
                           DOM1<D1+D2,T1> > { };
#define POOMA_NEWDOMAIN_JUST_SCALAR_SAME (   S,
  DOM 
)
Value:
template <>                              \
struct NewDomain2<S, S>                           \
  : public NewDomain2Base< S, S, DOM<2,S>, DOM<2,S> > { };
#define POOMA_NEWDOMAIN_JUST_SCALAR_OTHER (   S1,
  S2,
  DOM,
  S3 
)
Value:
template <>                              \
struct NewDomain2<S1, S2>                         \
  : public NewDomain2Base< S1, S2, DOM<2,S3>, DOM<2,S3> > { };            \
template <>                              \
struct NewDomain2<S2, S1>                         \
  : public NewDomain2Base< S2, S1, DOM<2,S3>, DOM<2,S3> > { };
#define POOMA_NEWDOMAIN_JUST_SCALAR_DOMAIN (   S,
  DOM1,
  DOM2 
)
Value:
template <int D1>                      \
struct NewDomain2< S, DOM1<D1> >                \
  : public NewDomain2Base< S, DOM1<D1>, DOM2<D1+1,S>, DOM2<D1+1,S> > { };  \
template <int D1>                      \
struct NewDomain2< DOM1<D1>, S >                \
  : public NewDomain2Base< DOM1<D1>, S, DOM2<D1+1,S>, DOM2<D1+1,S> > { };