Dune TypeTree (unstable)

generictransformationdescriptors.hh
1// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
2// vi: set et ts=4 sw=2 sts=2:
3// SPDX-FileCopyrightInfo: Copyright © DUNE Project contributors, see file LICENSE.md in module root
4// SPDX-License-Identifier: LGPL-3.0-or-later OR LicenseRef-GPL-2.0-only-with-PDELab-exception
5
6#ifndef DUNE_TYPETREE_GENERICTRANSFORMATIONDESCRIPTORS_HH
7#define DUNE_TYPETREE_GENERICTRANSFORMATIONDESCRIPTORS_HH
8
9#include <array>
10#include <memory>
11#include <vector>
12
13#include <dune/typetree/nodeinterface.hh>
14#include <dune/typetree/nodetags.hh>
15#include <dune/typetree/powercompositenodetransformationtemplates.hh>
16#include <dune/common/exceptions.hh>
17
18
19namespace Dune {
20 namespace TypeTree {
21
27 template<typename SourceNode, typename Transformation, typename TransformedNode>
28 struct GenericLeafNodeTransformation
29 {
30
31 static const bool recursive = false;
32
33 typedef TransformedNode transformed_type;
34 typedef std::shared_ptr<transformed_type> transformed_storage_type;
35
36 static transformed_type transform(const SourceNode& s, const Transformation& t)
37 {
38 return transformed_type(s,t);
39 }
40
41 static transformed_type transform(std::shared_ptr<const SourceNode> s, const Transformation& t)
42 {
43 return transformed_type(s,t);
44 }
45
46 static transformed_storage_type transform_storage(std::shared_ptr<const SourceNode> s, const Transformation& t)
47 {
48 return std::make_shared<transformed_type>(s,t);
49 }
50
51 };
52
53
54 template<typename SourceNode, typename Transformation, template<typename Child> class TransformedNodeTemplate>
55 struct TemplatizedGenericPowerNodeTransformation
56 {
57
58 static const bool recursive = true;
59
60 template<typename TC>
61 struct result
62 {
63 typedef typename TransformedNodeTemplate<TC>::type type;
64 typedef std::shared_ptr<type> storage_type;
65 static const std::size_t degree = StaticDegree<type>::value;
66 };
67
68 template<typename TC>
69 static typename result<TC>::type transform(const SourceNode& s, const Transformation& t, const std::array<std::shared_ptr<TC>,result<TC>::degree>& children)
70 {
71 return typename result<TC>::type(s,t,children);
72 }
73
74 template<typename TC>
75 static typename result<TC>::type transform(std::shared_ptr<const SourceNode> s, const Transformation& t, const std::array<std::shared_ptr<TC>,result<TC>::degree>& children)
76 {
77 return typename result<TC>::type(s,t,children);
78 }
79
80 template<typename TC>
81 static typename result<TC>::storage_type transform_storage(std::shared_ptr<const SourceNode> s, const Transformation& t, const std::array<std::shared_ptr<TC>,result<TC>::degree>& children)
82 {
83 return std::make_shared<typename result<TC>::type>(s,t,children);
84 }
85
86 };
87
88
89 template<typename SourceNode, typename Transformation, template<typename,typename,std::size_t> class TransformedNode>
90 struct GenericPowerNodeTransformation
91 : public TemplatizedGenericPowerNodeTransformation<SourceNode,
92 Transformation,
93 GenericPowerNodeTransformationTemplate<SourceNode,
94 Transformation,
95 TransformedNode>::template result
96 >
97 {};
98
99
100 template<typename SourceNode, typename Transformation, template<typename Child> class TransformedNodeTemplate>
101 struct TemplatizedGenericDynamicPowerNodeTransformation
102 {
103
104 static const bool recursive = true;
105
106 template<typename TC>
107 struct result
108 {
109 typedef typename TransformedNodeTemplate<TC>::type type;
110 typedef std::shared_ptr<type> storage_type;
111 };
112
113 template<typename TC>
114 static typename result<TC>::type transform(const SourceNode& s, const Transformation& t, const std::vector<std::shared_ptr<TC>>& children)
115 {
116 return typename result<TC>::type(s,t,children);
117 }
118
119 template<typename TC>
120 static typename result<TC>::type transform(std::shared_ptr<const SourceNode> s, const Transformation& t, const std::vector<std::shared_ptr<TC>>& children)
121 {
122 return typename result<TC>::type(s,t,children);
123 }
124
125 template<typename TC>
126 static typename result<TC>::storage_type transform_storage(std::shared_ptr<const SourceNode> s, const Transformation& t, const std::vector<std::shared_ptr<TC>>& children)
127 {
128 return std::make_shared<typename result<TC>::type>(s,t,children);
129 }
130
131 };
132
133
134 template<typename SourceNode, typename Transformation, template<typename,typename> class TransformedNode>
135 struct GenericDynamicPowerNodeTransformation
136 : public TemplatizedGenericDynamicPowerNodeTransformation<SourceNode,
137 Transformation,
138 GenericDynamicPowerNodeTransformationTemplate<SourceNode,
139 Transformation,
140 TransformedNode>::template result
141 >
142 {};
143
144
145 template<typename SourceNode, typename Transformation, template<typename...> class TransformedNodeTemplate>
146 struct TemplatizedGenericCompositeNodeTransformation
147 {
148
149 static const bool recursive = true;
150
151 template<typename... TC>
152 struct result
153 {
154 typedef typename TransformedNodeTemplate<TC...>::type type;
155 typedef std::shared_ptr<type> storage_type;
156 };
157
158 template<typename... TC>
159 static typename result<TC...>::type transform(const SourceNode& s, const Transformation& t, std::shared_ptr<TC>... children)
160 {
161 return typename result<TC...>::type(s,t,children...);
162 }
163
164 template<typename... TC>
165 static typename result<TC...>::type transform(std::shared_ptr<const SourceNode> s, const Transformation& t, std::shared_ptr<TC>... children)
166 {
167 return typename result<TC...>::type(s,t,children...);
168 }
169
170 template<typename... TC>
171 static typename result<TC...>::storage_type transform_storage(std::shared_ptr<const SourceNode> s, const Transformation& t, std::shared_ptr<TC>... children)
172 {
173 return std::make_shared<typename result<TC...>::type>(s,t,children...);
174 }
175
176 };
177
178
179 template<typename SourceNode, typename Transformation, template<typename,typename...> class TransformedNode>
180 struct GenericCompositeNodeTransformation
181 : public TemplatizedGenericCompositeNodeTransformation<SourceNode,
182 Transformation,
183 GenericCompositeNodeTransformationTemplate<SourceNode,
184 Transformation,
185 TransformedNode>::template result
186 >
187 {};
188
190
191 } // namespace TypeTree
192} //namespace Dune
193
194#endif // DUNE_TYPETREE_GENERICTRANSFORMATIONDESCRIPTORS_HH
Dune::TypeTree::degree
std::size_t degree(const Node &node)
Returns the degree of node as run time information.
Definition: nodeinterface.hh:79
Creative Commons License   |  Legal Statements / Impressum  |  Hosted by TU Dresden & Uni Heidelberg  |  generated with Hugo v0.111.3 (Jan 10, 23:35, 2026)