| // RUN: %llvmgxx %s -c -o /dev/null |
| // PR2917 |
| |
| #include <complex> |
| template < int Dim, class T, class EngineTag > class Engine; |
| template < class Subject, class Sub1, bool SV > struct View1Implementation; |
| template < class LayoutTag, class PatchTag > struct MultiPatch; |
| template < class LayoutTag, class PatchTag, int Dim2 > struct MultiPatchView; |
| template < class Engine, class SubDomain > struct NewEngine |
| { |
| }; |
| template < class T > class DomainTraits; |
| template < class DomT, class T, int Dim > struct DomainTraitsDomain |
| { |
| typedef DomT NewDomain1_t; |
| }; |
| template < int Dim > class Interval; |
| template < int Dim > class Loc; |
| template < class DT > class DomainBase |
| { |
| }; |
| |
| template < int Dim, class DT > class Domain:public DomainBase < DT > |
| { |
| }; |
| template < int Dim > struct DomainTraits <Interval < Dim > |
| >:public DomainTraitsDomain < Interval < Dim >, int, Dim > |
| { |
| enum |
| { |
| singleValued = false |
| }; |
| }; |
| template < class T1 > struct NewDomain1 |
| { |
| typedef typename DomainTraits < T1 >::NewDomain1_t SliceType_t; |
| }; |
| template < class Domain, class Sub > struct TemporaryNewDomain1 |
| { |
| typedef typename NewDomain1 < Sub >::SliceType_t SliceType_t; |
| }; |
| template < int Dim > class Interval:public Domain < Dim, |
| DomainTraits < Interval < Dim > > > |
| { |
| }; |
| template < int Dim > class GuardLayers |
| { |
| }; |
| template < class T > class Observer |
| { |
| }; |
| |
| template < class T > class Observable |
| { |
| private:T & observed_m; |
| int count_m; |
| }; |
| |
| class RefCounted |
| { |
| }; |
| template < class T > class RefCountedPtr |
| { |
| public:typedef RefCountedPtr < T > This_t; |
| RefCountedPtr (T * const pT):ptr_m (pT) |
| { |
| } |
| inline T *operator-> () const |
| { |
| } |
| T *ptr_m; |
| }; |
| |
| template < class Dom, class T > class DomainMap |
| { |
| }; |
| |
| template < class LayoutTag, int Dim > struct MultiPatchLayoutTraits |
| { |
| }; |
| template < int Dim > class LayoutBaseData |
| { |
| public:typedef Interval < Dim > Domain_t; |
| Domain_t domain_m; |
| }; |
| template < int Dim, class LBD > class LayoutBase |
| { |
| public:typedef LayoutBaseData < Dim > LayoutData_t; |
| typedef typename LayoutData_t::Domain_t Domain_t; |
| typedef GuardLayers < Dim > GuardLayers_t; |
| inline const Domain_t & domain () const |
| { |
| return pdata_m->domain_m; |
| } |
| inline const Domain_t & innerDomain () const |
| { |
| } |
| inline GuardLayers_t externalGuards () const |
| { |
| } |
| RefCountedPtr < LBD > pdata_m; |
| }; |
| template < class Tag > struct Remote; |
| struct Brick |
| { |
| }; |
| template < class Thing, class Sub > struct View1 |
| { |
| }; |
| template < int Dim, class T, class LayoutTag, |
| class PatchTag > struct NewEngine <Engine < Dim, T, MultiPatch < LayoutTag, |
| PatchTag > >, Interval < Dim > > |
| { |
| typedef Engine < Dim, T, MultiPatchView < LayoutTag, PatchTag, |
| Dim > >Type_t; |
| }; |
| template < int Dim, class T, class LayoutTag, class PatchTag, |
| int Dim2 > struct NewEngine <Engine < Dim, T, MultiPatchView < LayoutTag, |
| PatchTag, Dim2 > >, Interval < Dim > > |
| { |
| typedef Engine < Dim, T, MultiPatchView < LayoutTag, PatchTag, |
| Dim2 > >Type_t; |
| }; |
| template < int Dim, class T, class LayoutTag, |
| class PatchTag > class Engine < Dim, T, MultiPatch < LayoutTag, |
| PatchTag > >:public Observer < typename MultiPatchLayoutTraits < LayoutTag, |
| Dim >::Layout_t > |
| { |
| public:typedef MultiPatch < LayoutTag, PatchTag > Tag_t; |
| typedef Interval < Dim > Domain_t; |
| }; |
| template < int Dim, class T, class LayoutTag, class PatchTag, |
| int Dim2 > class Engine < Dim, T, MultiPatchView < LayoutTag, PatchTag, |
| Dim2 > > |
| { |
| public:typedef MultiPatchView < LayoutTag, PatchTag, Dim2 > Tag_t; |
| typedef Interval < Dim > Domain_t; |
| typedef T Element_t; |
| enum |
| { |
| dimensions = Dim |
| }; |
| }; |
| class Full; |
| template < int Dim, class T = double, class EngineTag = Full > class Vector { |
| }; |
| |
| template < int Dim > inline Interval < Dim > |
| shrinkRight (const Interval < Dim > &dom, int s) |
| { |
| } |
| |
| template < int Dim > class GridLayout; |
| struct GridTag |
| { |
| }; |
| template < int Dim > struct MultiPatchLayoutTraits <GridTag, Dim > |
| { |
| typedef GridLayout < Dim > Layout_t; |
| }; |
| template < int Dim > class GridLayoutData:public LayoutBaseData < Dim >, |
| public RefCounted, public Observable < GridLayoutData < Dim > > |
| { |
| typedef int AxisIndex_t; |
| mutable DomainMap < Interval < 1 >, AxisIndex_t > mapAloc_m[Dim]; |
| }; |
| template < int Dim > class GridLayout:public LayoutBase < Dim, |
| GridLayoutData < Dim > >, public Observable < GridLayout < Dim > >, |
| public Observer < GridLayoutData < Dim > > |
| { |
| public:typedef GridLayout < Dim > This_t; |
| GridLayout (); |
| }; |
| template < class MeshTag, class T, class EngineTag > class Field; |
| enum CenteringType |
| { |
| VertexType, EdgeType, FaceType, CellType |
| }; |
| enum ContinuityType |
| { |
| Continuous = 0, Discontinuous |
| }; |
| template < int Dim > class Centering |
| { |
| public:typedef Loc < Dim > Orientation; |
| inline int size () const |
| { |
| } |
| }; |
| template < int Dim > const Centering < Dim > |
| canonicalCentering (const enum CenteringType type, |
| const enum ContinuityType discontinuous, |
| const int dimension = 0); |
| template < class Mesh, class T, class EngineTag > class FieldEngine |
| { |
| public:enum |
| { |
| dimensions = Mesh::dimensions |
| }; |
| enum |
| { |
| Dim = dimensions |
| }; |
| typedef Engine < Dim, T, EngineTag > Engine_t; |
| typedef typename Engine_t::Domain_t Domain_t; |
| typedef GuardLayers < Dim > GuardLayers_t; |
| template < class Layout2 > FieldEngine (const Centering < Dim > ¢ering, const Layout2 & layout, const Mesh & mesh, int materials = 1):num_materials_m (materials), centering_m (centering), |
| stride_m (centering.size ()), physicalCellDomain_m (layout.domain ()), |
| guards_m (layout.externalGuards ()), mesh_m (mesh) |
| { |
| } |
| unsigned int num_materials_m; |
| Centering < Dim > centering_m; |
| int stride_m; |
| Domain_t physicalCellDomain_m; |
| GuardLayers_t guards_m; |
| Mesh mesh_m; |
| }; |
| |
| template < class Subject > class SubFieldView; |
| template < class Mesh, class T, |
| class EngineTag > class SubFieldView < Field < Mesh, T, EngineTag > > |
| { |
| public:typedef Field < Mesh, T, EngineTag > Type_t; |
| }; |
| |
| template < int Dim, class Mesh, class Domain > struct NewMeshTag |
| { |
| typedef Mesh Type_t; |
| }; |
| template < class Mesh, class T, class EngineTag, |
| class Domain > struct View1Implementation <Field < Mesh, T, EngineTag >, |
| Domain, false > |
| { |
| typedef Field < Mesh, T, EngineTag > Subject_t; |
| typedef typename Subject_t::Engine_t Engine_t; |
| typedef typename NewEngine < Engine_t, Domain >::Type_t NewEngine_t; |
| typedef typename NewEngine_t::Element_t NewT_t; |
| typedef typename NewEngine_t::Tag_t NewEngineTag_t; |
| typedef typename NewMeshTag < NewEngine_t::dimensions, Mesh, |
| Domain >::Type_t NewMeshTag_t; |
| typedef Field < NewMeshTag_t, NewT_t, NewEngineTag_t > Type_t; |
| }; |
| template < class Mesh, class T, class EngineTag, |
| class Sub1 > struct View1 <Field < Mesh, T, EngineTag >, Sub1 > |
| { |
| typedef Field < Mesh, T, EngineTag > Subject_t; |
| typedef typename Subject_t::Domain_t Domain_t; |
| typedef TemporaryNewDomain1 < Domain_t, Sub1 > NewDomain_t; |
| typedef typename NewDomain_t::SliceType_t SDomain_t; |
| enum |
| { |
| sv = DomainTraits < SDomain_t >::singleValued |
| }; |
| typedef View1Implementation < Subject_t, SDomain_t, sv > Dispatch_t; |
| typedef typename Dispatch_t::Type_t Type_t; |
| }; |
| template < class Mesh, class T = double, class EngineTag = Brick > class Field { |
| public:typedef Mesh MeshTag_t; |
| typedef Mesh Mesh_t; |
| typedef Field < Mesh, T, EngineTag > This_t; |
| typedef FieldEngine < Mesh, T, EngineTag > FieldEngine_t; |
| enum |
| { |
| dimensions = FieldEngine_t::dimensions |
| }; |
| typedef Engine < dimensions, T, EngineTag > Engine_t; |
| typedef typename Engine_t::Domain_t Domain_t; |
| typedef Centering < dimensions > Centering_t; |
| template < class Layout2 > Field (const Centering_t & centering, |
| const Layout2 & layout, |
| const Mesh_t & |
| mesh):fieldEngine_m (centering, layout, |
| mesh) |
| { |
| } |
| inline typename SubFieldView < This_t >::Type_t center (int c) const |
| { |
| } |
| inline typename View1 < This_t, Domain_t >::Type_t all () const |
| { |
| } |
| template < class T1 > const This_t & operator= (const T1 & rhs) const |
| { |
| } |
| private: FieldEngine_t fieldEngine_m; |
| }; |
| |
| struct UniformRectilinearTag |
| { |
| }; |
| struct CartesianTag |
| { |
| }; |
| template < class MeshTraits > struct CartesianURM; |
| template < class MeshTraits > class UniformRectilinearMeshData; |
| template < class MeshTraits > class UniformRectilinearMesh; |
| template < int Dim, typename T = double, class MeshTag = |
| UniformRectilinearTag, class CoordinateSystemTag = CartesianTag, int CDim = |
| Dim > struct MeshTraits; |
| template < int Dim, typename T, class MeshTag, class CoordinateSystemTag, |
| int CDim > struct MeshTraitsBase |
| { |
| typedef MeshTraits < Dim, T, MeshTag, CoordinateSystemTag, |
| CDim > MeshTraits_t; |
| enum |
| { |
| dimensions = Dim |
| }; |
| typedef Vector < CDim, T > PointType_t; |
| }; |
| template < int Dim, typename T, int CDim > struct MeshTraits <Dim, T, |
| UniformRectilinearTag, CartesianTag, CDim >:public MeshTraitsBase < Dim, T, |
| UniformRectilinearTag, CartesianTag, CDim > |
| { |
| typedef typename MeshTraitsBase < Dim, T, UniformRectilinearTag, |
| CartesianTag, CDim >::MeshTraits_t MeshTraits_t; |
| typedef CartesianURM < MeshTraits_t > CoordinateSystem_t; |
| typedef UniformRectilinearMeshData < MeshTraits_t > MeshData_t; |
| typedef UniformRectilinearMesh < MeshTraits_t > Mesh_t; |
| typedef Vector < CDim, T > SpacingsType_t; |
| }; |
| template < int Dim > class NoMeshData:public RefCounted |
| { |
| public:NoMeshData () |
| { |
| } |
| template < class Layout > |
| explicit NoMeshData (const Layout & |
| layout):physicalVertexDomain_m (layout. |
| innerDomain ()), |
| physicalCellDomain_m (shrinkRight (physicalVertexDomain_m, 1)), |
| totalVertexDomain_m (layout.domain ()), |
| totalCellDomain_m (shrinkRight (totalVertexDomain_m, 1)) |
| { |
| } |
| private:Interval < Dim > physicalVertexDomain_m, physicalCellDomain_m; |
| Interval < Dim > totalVertexDomain_m, totalCellDomain_m; |
| }; |
| |
| template < class MeshTraits > class UniformRectilinearMeshData:public NoMeshData < |
| MeshTraits:: |
| dimensions > |
| { |
| public:typedef typename |
| MeshTraits::MeshData_t |
| MeshData_t; |
| typedef typename |
| MeshTraits::PointType_t |
| PointType_t; |
| typedef typename |
| MeshTraits::SpacingsType_t |
| SpacingsType_t; |
| enum |
| { |
| dimensions = MeshTraits::dimensions |
| }; |
| template < class Layout > UniformRectilinearMeshData (const Layout & layout, |
| const PointType_t & |
| origin, |
| const SpacingsType_t & |
| spacings): |
| NoMeshData < |
| dimensions > (layout), |
| origin_m (origin), |
| spacings_m (spacings) |
| { |
| } |
| private:PointType_t origin_m; |
| SpacingsType_t |
| spacings_m; |
| }; |
| |
| template < class MeshTraits > class UniformRectilinearMesh:public MeshTraits:: |
| CoordinateSystem_t |
| { |
| public:typedef MeshTraits |
| MeshTraits_t; |
| typedef typename |
| MeshTraits::MeshData_t |
| MeshData_t; |
| typedef typename |
| MeshTraits::PointType_t |
| PointType_t; |
| typedef typename |
| MeshTraits::SpacingsType_t |
| SpacingsType_t; |
| enum |
| { |
| dimensions = MeshTraits::dimensions |
| }; |
| template < class Layout > |
| inline UniformRectilinearMesh (const Layout & layout, |
| const PointType_t & origin, |
| const SpacingsType_t & spacings): |
| data_m (new MeshData_t (layout, origin, spacings)) |
| { |
| } |
| private:RefCountedPtr < MeshData_t > data_m; |
| }; |
| |
| template < class MeshTraits > struct GenericURM |
| { |
| }; |
| template < class MeshTraits > struct CartesianURM: |
| public |
| GenericURM < |
| MeshTraits > |
| { |
| }; |
| template < int |
| dim, |
| class |
| MeshTag = UniformRectilinearTag, class CoordinateSystemTag = CartesianTag > struct ParallelTraits { |
| enum |
| { |
| Dim = dim |
| }; |
| typedef |
| GridLayout < |
| dim > |
| Layout_t; |
| typedef |
| MeshTraits < |
| dim, double, |
| MeshTag, |
| CoordinateSystemTag > |
| MeshTraits_t; |
| typedef typename |
| MeshTraits_t::Mesh_t |
| Mesh_t; |
| typedef |
| MultiPatch < |
| GridTag, |
| Remote < |
| Brick > > |
| Engine_t; |
| }; |
| template < class ComputeTraits > struct RhalkTraits: |
| public |
| ComputeTraits |
| { |
| typedef typename |
| ComputeTraits::Mesh_t |
| Mesh_t; |
| typedef typename |
| ComputeTraits::Engine_t |
| Engine_t; |
| enum |
| { |
| Dim = ComputeTraits::Dim |
| }; |
| typedef |
| Centering < |
| Dim > |
| Centering_t; |
| typedef typename |
| Mesh_t::SpacingsType_t |
| Spacings_t; |
| typedef |
| Field < |
| Mesh_t, double, |
| Engine_t > |
| Scalar_t; |
| }; |
| enum |
| { |
| Dim = 3 |
| }; |
| typedef |
| RhalkTraits < |
| ParallelTraits < |
| Dim, |
| UniformRectilinearTag, |
| CartesianTag > > |
| Traits_t; |
| Vector < Dim > origin; |
| Traits_t::Spacings_t spacings; |
| int |
| main (int argc, char **argv) |
| { |
| Traits_t::Layout_t layout; |
| Traits_t::Mesh_t mesh (layout, origin, spacings); |
| Traits_t::Centering_t face = |
| canonicalCentering < Traits_t::Dim > (FaceType, Continuous); |
| Traits_t::Scalar_t v (face, layout, mesh); |
| for (int i = 0; i < Dim; ++i) |
| v.center (i).all () = std::numeric_limits < double >::signaling_NaN (); |
| } |
