diff --git a/_derived_reference_wrapper_variant_traits_8hpp_source.html b/_derived_reference_wrapper_variant_traits_8hpp_source.html new file mode 100644 index 0000000000..62308aad37 --- /dev/null +++ b/_derived_reference_wrapper_variant_traits_8hpp_source.html @@ -0,0 +1,101 @@ + + + + + + + +Wildmeshing Toolkit: /opt/wmtk-wildmeshing-actions-runner/_work/wildmeshing-toolkit/wildmeshing-toolkit/src/wmtk/utils/metaprogramming/DerivedReferenceWrapperVariantTraits.hpp Source File + + + + + + + + + +
+
+ + + + + + +
+
Wildmeshing Toolkit +
+
+
+ + + + + + + + +
+
+ + +
+ +
+ + +
+
+
+
DerivedReferenceWrapperVariantTraits.hpp
+
+
+
1 #pragma once
+
2 #include <tuple>
+
3 
+
4 #include "ReferenceWrapperVariant.hpp"
+
5 namespace wmtk::utils::metaprogramming {
+
6 template <typename BaseType_, typename... DerivedTypes>
+ +
8 {
+
9  using BaseType = BaseType_;
+
10 
+
11  // we keep a plain derived type tuple for convenience
+
12  using DerivedTypesTuple = std::tuple<DerivedTypes...>;
+
13  // we keep reference types of derived type tuple for convenience
+
14  using ReferenceTuple = std::tuple<std::reference_wrapper<DerivedTypes>...>;
+
15 
+
16  // The reference class for this type
+
17  using ReferenceVariant = std::variant<std::reference_wrapper<DerivedTypes>...>;
+
18 
+
19  static size_t get_index(const BaseType& t);
+
20 };
+
21 
+
22 } // namespace wmtk::utils::metaprogramming
+
Definition: DerivedReferenceWrapperVariantTraits.hpp:8
+
+ + + + diff --git a/_reference_wrapped_functor_return_cache_8hpp_source.html b/_reference_wrapped_functor_return_cache_8hpp_source.html new file mode 100644 index 0000000000..fc5055bfb4 --- /dev/null +++ b/_reference_wrapped_functor_return_cache_8hpp_source.html @@ -0,0 +1,171 @@ + + + + + + + +Wildmeshing Toolkit: /opt/wmtk-wildmeshing-actions-runner/_work/wildmeshing-toolkit/wildmeshing-toolkit/src/wmtk/utils/metaprogramming/ReferenceWrappedFunctorReturnCache.hpp Source File + + + + + + + + + +
+
+ + + + + + +
+
Wildmeshing Toolkit +
+
+
+ + + + + + + + +
+
+ + +
+ +
+ + +
+
+
+
ReferenceWrappedFunctorReturnCache.hpp
+
+
+
1 #pragma once
+
2 #include <map>
+
3 #include <tuple>
+
4 
+
5 #include "ReferenceWrappedFunctorReturnType.hpp"
+
6 namespace wmtk::utils::metaprogramming {
+
7 
+
8 // Interface for reading off the return values from data
+
9 template <typename Functor, typename BaseVariantTraitsType, typename... OtherArgumentTypes>
+ +
11 {
+
12 public:
+
13  using TypeHelper =
+
14  ReferenceWrappedFunctorReturnType<Functor, BaseVariantTraitsType, OtherArgumentTypes...>;
+
15  using ReturnVariant = typename TypeHelper::type;
+
16 
+
17  using RefVariantType = typename BaseVariantTraitsType::ReferenceVariant;
+
18  using BaseType = typename BaseVariantTraitsType::BaseType;
+
19  using TupleType = typename BaseVariantTraitsType::DerivedTypesTuple;
+
20  using RefTupleType = typename BaseVariantTraitsType::ReferenceTuple;
+
21 
+
22  // Add new data by giving the InputType
+
23  // InputType is used to make sure the pair of Input/Output is valid and to
+
24  // extract an id
+
25  // NOTE this passes value then key because the key can have variable arguments :(
+
26  template <typename InputType, typename ReturnType>
+
27  void add(ReturnType&& return_data, const InputType& input, const OtherArgumentTypes&... args)
+
28  {
+
29  using ReturnType_t = std::decay_t<ReturnType>;
+
30  static_assert(
+
31  !std::is_same_v<std::decay_t<InputType>, BaseType>,
+
32  "Don't pass in a input, use variant/visitor to get its "
+
33  "derived type");
+
34  // static_assert(
+
35  // !std::
+
36  // holds_alternative<std::reference_wrapper<std::decay_t<InputType>>,
+
37  // RefVariantType>,
+
38  // "the input type must be seen in the set of valid input variants");
+
39  // if the user passed in a input class lets try re-invoking with a
+
40  // derived type
+
41  auto id = get_id(input, args...);
+
42  using ExpectedReturnType = typename TypeHelper::template ReturnType<InputType>;
+
43 
+
44  static_assert(
+
45  std::is_convertible_v<ReturnType_t, ExpectedReturnType>,
+
46  "Second argument should be the return value of a Functor "
+
47  "(or convertible at "
+
48  "least) ");
+
49 
+
50  m_data.emplace(
+
51  id,
+
52  ReturnVariant(
+
53  std::in_place_type_t<ExpectedReturnType>{},
+
54  std::forward<ReturnType>(return_data)));
+
55  }
+
56 
+
57 
+
58  // get the type specific input
+
59  template <typename InputType>
+
60  auto get(const InputType& input, const OtherArgumentTypes&... ts) const
+
61  {
+
62  static_assert(
+
63  !std::is_same_v<std::decay_t<InputType>, BaseType>,
+
64  "Don't pass in a input, use variant/visitor to get its "
+
65  "derived type");
+
66  using ExpectedReturnType = typename TypeHelper::template ReturnType<InputType>;
+
67 
+
68  return std::get<ExpectedReturnType>(get_variant(input, ts...));
+
69  }
+
70 
+
71  // let user get the variant for a specific Input derivate
+
72  const auto& get_variant(const BaseType& input, const OtherArgumentTypes&... ts) const
+
73  {
+
74  auto id = get_id(input, ts...);
+
75  return m_data.at(id);
+
76  }
+
77 
+
78 private:
+
79  // a pointer to an input and some other arguments
+
80  using KeyType = std::tuple<const BaseType*, OtherArgumentTypes...>;
+
81 
+
82  auto get_id(const BaseType& input, const OtherArgumentTypes&... ts) const
+
83  {
+
84  // other applications might use a fancier version of get_id
+
85  return KeyType(&input, ts...);
+
86  }
+
87 
+
88  std::map<KeyType, ReturnVariant> m_data;
+
89 };
+
90 
+
91 } // namespace wmtk::utils::metaprogramming
+
Definition: ReferenceWrappedFunctorReturnCache.hpp:11
+
Definition: ReferenceWrappedFunctorReturnType.hpp:14
+
+ + + + diff --git a/_reference_wrapped_functor_return_type_8hpp_source.html b/_reference_wrapped_functor_return_type_8hpp_source.html new file mode 100644 index 0000000000..2c9e4aea19 --- /dev/null +++ b/_reference_wrapped_functor_return_type_8hpp_source.html @@ -0,0 +1,114 @@ + + + + + + + +Wildmeshing Toolkit: /opt/wmtk-wildmeshing-actions-runner/_work/wildmeshing-toolkit/wildmeshing-toolkit/src/wmtk/utils/metaprogramming/ReferenceWrappedFunctorReturnType.hpp Source File + + + + + + + + + +
+
+ + + + + + +
+
Wildmeshing Toolkit +
+
+
+ + + + + + + + +
+
+ + +
+ +
+ + +
+
+
+
ReferenceWrappedFunctorReturnType.hpp
+
+
+
1 #pragma once
+
2 #include <tuple>
+
3 
+
4 #include "DerivedReferenceWrapperVariantTraits.hpp"
+
5 #include "unwrap_ref.hpp"
+
6 namespace wmtk::utils::metaprogramming {
+
7 
+
8 namespace detail {
+
9 // A helper class for specifying per-type return types from an input functor
+
10 // Assumes the argument is the variant type being selected form, all other
+
11 // arguments are passed in as const references
+
12 template <typename Functor, typename... Ts>
+ +
14 {
+
15 };
+
16 template <typename Functor, typename... VTs, typename... Ts>
+
17 struct ReferenceWrappedFunctorReturnType<Functor, std::tuple<VTs...>, Ts...>
+
18 {
+
19  // For a specific type in the variant, get the return type
+
20  template <typename T>
+
21  using ReturnType =
+
22  std::decay_t<std::invoke_result_t<Functor, unwrap_ref_decay_t<T>&, const Ts&...>>;
+
23 
+
24  // Get an overall variant for the types
+
25  using type = std::variant<ReturnType<VTs>...>;
+
26 };
+
27 } // namespace detail
+
28 
+
29 template <typename Functor, typename ReferenceWrapperTraits, typename... Ts>
+ +
31  Functor,
+
32  typename ReferenceWrapperTraits::ReferenceTuple,
+
33  Ts...>;
+
34 
+
35 } // namespace wmtk::utils::metaprogramming
+
Definition: ReferenceWrappedFunctorReturnType.hpp:14
+
+ + + + diff --git a/_reference_wrapper_variant_8hpp_source.html b/_reference_wrapper_variant_8hpp_source.html new file mode 100644 index 0000000000..42c220b08a --- /dev/null +++ b/_reference_wrapper_variant_8hpp_source.html @@ -0,0 +1,96 @@ + + + + + + + +Wildmeshing Toolkit: /opt/wmtk-wildmeshing-actions-runner/_work/wildmeshing-toolkit/wildmeshing-toolkit/src/wmtk/utils/metaprogramming/ReferenceWrapperVariant.hpp Source File + + + + + + + + + +
+
+ + + + + + +
+
Wildmeshing Toolkit +
+
+
+ + + + + + + + +
+
+ + +
+ +
+ + +
+
+
+
ReferenceWrapperVariant.hpp
+
+
+
1 #pragma once
+
2 #include <functional>
+
3 #include <type_traits>
+
4 #include <utility>
+
5 #include <variant>
+
6 
+
7 namespace wmtk::utils::metaprogramming {
+
8 
+
9 // My target application's "Input" class is quite heavy and the Input objects
+
10 // persist for long periods of time relative to what this is being used for, so
+
11 // I want to use a variant of references rather than values
+
12 //
+
13 // Here's a helper definition for making variants of references
+
14 template <typename... T>
+
15 using ReferenceWrapperVariant = std::variant<std::reference_wrapper<T>...>;
+
16 
+
17 
+
18 } // namespace wmtk::utils::metaprogramming
+
+ + + + diff --git a/annotated.html b/annotated.html index 9222ed9600..3a6bd6a624 100644 --- a/annotated.html +++ b/annotated.html @@ -138,43 +138,54 @@  CSimplex  CSimplexCollection  Nutils - CTupleCellLessThan - CTupleInspector - CAttributeCacheData - CEdgeMesh - CEdgeMeshOperationExecutor - CInteriorEdgeInvariant - CInteriorVertexInvariant - CInvariant - CInvariantCollection - CMaxEdgeLengthInvariant - CMeshInvariant - CMinEdgeLengthInvariant - CTetMeshInvariant - CTriMeshInvariant - CTriMeshLinkConditionInvariant - CValidTupleInvariant - CHDF5Writer - CMeshReader - CMeshWriter - CParaviewWriter - CParaviewInternalWriter - CMesh - CMultiMeshManager - CChildData - CPointMesh - CScheduler - CSimplicialComplex - CTetMesh - CTetMeshOperationExecutor - CTriMesh - CTriMeshOperationExecutor - CTuple - CRational - CAMIPS_2D - CAMIPS_3DTODO 3D AMIPS uses uv and displacement map to get the 3d cooridnates then evaluate - CDifferentiableEnergy - CEnergy + Nmetaprogramming + Ndetail + Cas_variant_impl + Cas_variant_impl< BaseVariantTraitsType, std::tuple< DerivedTypes... >, Index > + CReferenceWrappedFunctorReturnType + CReferenceWrappedFunctorReturnType< Functor, std::tuple< VTs... >, Ts... > + CDerivedReferenceWrapperVariantTraits + CReferenceWrappedFunctorReturnCache + Cunwrap_reference + Cunwrap_reference< std::reference_wrapper< U > > + Cunwrap_ref_decay + CTupleCellLessThan + CTupleInspector + CAttributeCacheData + CEdgeMesh + CEdgeMeshOperationExecutor + CInteriorEdgeInvariant + CInteriorVertexInvariant + CInvariant + CInvariantCollection + CMaxEdgeLengthInvariant + CMeshInvariant + CMinEdgeLengthInvariant + CTetMeshInvariant + CTriMeshInvariant + CTriMeshLinkConditionInvariant + CValidTupleInvariant + CHDF5Writer + CMeshReader + CMeshWriter + CParaviewWriter + CParaviewInternalWriter + CMesh + CMultiMeshManager + CChildData + CPointMesh + CScheduler + CSimplicialComplex + CTetMesh + CTetMeshOperationExecutor + CTriMesh + CTriMeshOperationExecutor + CTuple + CRational + CAMIPS_2D + CAMIPS_3DTODO 3D AMIPS uses uv and displacement map to get the 3d cooridnates then evaluate + CDifferentiableEnergy + CEnergy diff --git a/as__variant_8hpp_source.html b/as__variant_8hpp_source.html new file mode 100644 index 0000000000..eca7a48bb6 --- /dev/null +++ b/as__variant_8hpp_source.html @@ -0,0 +1,141 @@ + + + + + + + +Wildmeshing Toolkit: /opt/wmtk-wildmeshing-actions-runner/_work/wildmeshing-toolkit/wildmeshing-toolkit/src/wmtk/utils/metaprogramming/as_variant.hpp Source File + + + + + + + + + +
+
+ + + + + + +
+
Wildmeshing Toolkit +
+
+
+ + + + + + + + +
+
+ + +
+ +
+ + +
+
+
+
as_variant.hpp
+
+
+
1 #pragma once
+
2 
+
3 #include "DerivedReferenceWrapperVariantTraits.hpp"
+
4 namespace wmtk::utils::metaprogramming {
+
5 namespace detail {
+
6 
+
7 template <typename BaseVariantTraitsType, typename TupleType, size_t Index>
+ +
9 {
+
10  using RetType = typename BaseVariantTraitsType::ReferenceVariant;
+
11  using BaseType = typename BaseVariantTraitsType::BaseType;
+
12  static RetType exec(BaseType& value, size_t index);
+
13 };
+
14 template <typename BaseVariantTraitsType, typename... DerivedTypes, size_t Index>
+
15 struct as_variant_impl<BaseVariantTraitsType, std::tuple<DerivedTypes...>, Index>
+
16 {
+
17  using RetType = typename BaseVariantTraitsType::ReferenceVariant;
+
18  using BaseType = typename BaseVariantTraitsType::BaseType;
+
19  using TupleType = typename BaseVariantTraitsType::DerivedTypesTuple;
+
20  using RefTupleType = typename BaseVariantTraitsType::ReferenceTuple;
+
21 
+
22  using MyRefType = std::tuple_element_t<Index, RefTupleType>;
+
23  using MyDerivedType = std::tuple_element_t<Index, TupleType>;
+
24 
+
25  using FirstRefType = std::tuple_element_t<0, RefTupleType>;
+
26  using FirstDerivedType = std::tuple_element_t<0, TupleType>;
+
27  static RetType exec(BaseType& value, size_t index)
+
28  {
+
29  // handle case that the type isn't found / settle base case
+
30  if constexpr (Index < sizeof...(DerivedTypes)) {
+
31  if (index == Index) {
+
32  return RetType(
+
33  std::in_place_type_t<MyRefType>{},
+
34  static_cast<MyDerivedType&>(value));
+
35  } else {
+
36  if constexpr (Index + 1 < sizeof...(DerivedTypes)) {
+ +
38  value,
+
39  index);
+
40  }
+
41  }
+
42  }
+
43  throw "Invalid Input";
+
44  // This should never happen, just making a dummy to suppress warnings
+
45  return RetType(
+
46  std::in_place_type_t<FirstRefType>{},
+
47  reinterpret_cast<FirstDerivedType&>(value));
+
48  }
+
49 };
+
50 } // namespace detail
+
51 
+
52 template <typename BaseVariantTraitsType>
+
53 typename BaseVariantTraitsType::ReferenceVariant as_variant(
+
54  typename BaseVariantTraitsType::BaseType& value)
+
55 {
+
56  using impl = detail::as_variant_impl<
+
57  BaseVariantTraitsType,
+
58  typename BaseVariantTraitsType::DerivedTypesTuple,
+
59  0>;
+
60  return impl::exec(value, BaseVariantTraitsType::get_index(value));
+
61 }
+
62 } // namespace wmtk::utils::metaprogramming
+ +
+ + + + diff --git a/classes.html b/classes.html index 8bd27c4329..eadc953b5b 100644 --- a/classes.html +++ b/classes.html @@ -65,17 +65,17 @@
Class Index
-
A | C | D | E | F | H | I | L | M | O | P | R | S | T | V
+
A | C | D | E | F | H | I | L | M | O | P | R | S | T | U | V
A
-
AccessorBase (wmtk::attribute)
AccessorCache (wmtk::attribute)
AMIPS_2D
AMIPS_3D
Attribute (wmtk::attribute)
AttributeCache (wmtk::attribute)
AttributeCacheData (wmtk)
AttributeHandle (wmtk::attribute)
AttributeManager (wmtk::attribute)
AttributeScope (wmtk::attribute)
AttributeScopeHandle (wmtk::attribute)
AttributeScopeStack (wmtk::attribute)
+
AccessorBase (wmtk::attribute)
AccessorCache (wmtk::attribute)
AMIPS_2D
AMIPS_3D
as_variant_impl (wmtk::utils::metaprogramming::detail)
as_variant_impl< BaseVariantTraitsType, std::tuple< DerivedTypes... >, Index > (wmtk::utils::metaprogramming::detail)
Attribute (wmtk::attribute)
AttributeCache (wmtk::attribute)
AttributeCacheData (wmtk)
AttributeHandle (wmtk::attribute)
AttributeManager (wmtk::attribute)
AttributeScope (wmtk::attribute)
AttributeScopeHandle (wmtk::attribute)
AttributeScopeStack (wmtk::attribute)
C
CachingAccessor (wmtk::attribute)
MultiMeshManager::ChildData (wmtk)
ClosedStarIterable (wmtk::simplex)
ConstAccessor (wmtk::attribute)
D
-
DifferentiableEnergy
+
DerivedReferenceWrapperVariantTraits (wmtk::utils::metaprogramming)
DifferentiableEnergy
E
EdgeOperationData::EarFace (wmtk::operations::tri_mesh)
EdgeOperationData::EarTet (wmtk::operations::tet_mesh)
EdgeCollapse (wmtk::operations::tri_mesh)
EdgeCollapseToMidpoint (wmtk::operations::tri_mesh)
EdgeMesh (wmtk)
EdgeMeshOperation (wmtk::operations::edge_mesh)
EdgeMesh::EdgeMeshOperationExecutor (wmtk)
EdgeOperationData (wmtk::operations::edge_mesh)
EdgeOperationData (wmtk::operations::tet_mesh)
EdgeOperationData (wmtk::operations::tri_mesh)
EdgeSplit (wmtk::operations::tri_mesh)
EdgeSplitAtMidpoint (wmtk::operations::tri_mesh)
EdgeSwap (wmtk::operations::tri_mesh)
Energy
@@ -102,7 +102,7 @@
ParaviewWriter::ParaviewInternalWriter (wmtk)
ParaviewWriter (wmtk)
PerThreadAttributeScopeStacks (wmtk::attribute)
PointMesh (wmtk)
R
-
Rational (wmtk)
+
Rational (wmtk)
ReferenceWrappedFunctorReturnCache (wmtk::utils::metaprogramming)
ReferenceWrappedFunctorReturnType (wmtk::utils::metaprogramming::detail)
ReferenceWrappedFunctorReturnType< Functor, std::tuple< VTs... >, Ts... > (wmtk::utils::metaprogramming::detail)
S
Scheduler (wmtk)
Simplex (wmtk::simplex)
SimplexBoundaryIterable (wmtk::simplex)
SimplexCollection (wmtk::simplex)
SimplexEqualFunctor (wmtk::simplex::internal)
SimplexLessFunctor (wmtk::internal)
SimplexLessFunctor (wmtk::simplex::internal)
SimplicialComplex (wmtk)
@@ -110,6 +110,9 @@
T
EdgeOperationData::TetCollapseData (wmtk::operations::tet_mesh)
TetMesh (wmtk)
TetMeshInvariant (wmtk)
TetMeshOperation (wmtk::operations::tet_mesh)
TetMesh::TetMeshOperationExecutor (wmtk)
EdgeOperationData::TetSplitData (wmtk::operations::tet_mesh)
TopLevelCofacesIterable (wmtk::simplex)
TriMesh (wmtk)
TriMeshInvariant (wmtk)
TriMeshLinkConditionInvariant (wmtk)
TriMeshOperation (wmtk::operations::tri_mesh)
TriMesh::TriMeshOperationExecutor (wmtk)
Tuple (wmtk)
TupleAccessor (wmtk::attribute)
TupleCellLessThan (wmtk::utils)
TupleInspector (wmtk::utils)
TupleOperation (wmtk::operations)
+
U
+
unwrap_ref_decay (wmtk::utils::metaprogramming)
unwrap_reference (wmtk::utils::metaprogramming)
unwrap_reference< std::reference_wrapper< U > > (wmtk::utils::metaprogramming)
+
V
ValidTupleInvariant (wmtk)
VertexAttributesUpdateBase (wmtk::operations::tri_mesh)
VertexLaplacianSmooth (wmtk::operations::tri_mesh)
VertexTangentialLaplacianSmooth (wmtk::operations::tri_mesh)
diff --git a/classwmtk_1_1utils_1_1metaprogramming_1_1_reference_wrapped_functor_return_cache-members.html b/classwmtk_1_1utils_1_1metaprogramming_1_1_reference_wrapped_functor_return_cache-members.html new file mode 100644 index 0000000000..bc63d2b2ab --- /dev/null +++ b/classwmtk_1_1utils_1_1metaprogramming_1_1_reference_wrapped_functor_return_cache-members.html @@ -0,0 +1,93 @@ + + + + + + + +Wildmeshing Toolkit: Member List + + + + + + + + + +
+
+ + + + + + +
+
Wildmeshing Toolkit +
+
+
+ + + + + + + + +
+
+ + +
+ +
+ + +
+
+
+
wmtk::utils::metaprogramming::ReferenceWrappedFunctorReturnCache< Functor, BaseVariantTraitsType, OtherArgumentTypes > Member List
+
+
+ +

This is the complete list of members for wmtk::utils::metaprogramming::ReferenceWrappedFunctorReturnCache< Functor, BaseVariantTraitsType, OtherArgumentTypes >, including all inherited members.

+ + + + + + + + + + + + + +
add(ReturnType &&return_data, const InputType &input, const OtherArgumentTypes &... args) (defined in wmtk::utils::metaprogramming::ReferenceWrappedFunctorReturnCache< Functor, BaseVariantTraitsType, OtherArgumentTypes >)wmtk::utils::metaprogramming::ReferenceWrappedFunctorReturnCache< Functor, BaseVariantTraitsType, OtherArgumentTypes >inline
BaseType typedef (defined in wmtk::utils::metaprogramming::ReferenceWrappedFunctorReturnCache< Functor, BaseVariantTraitsType, OtherArgumentTypes >)wmtk::utils::metaprogramming::ReferenceWrappedFunctorReturnCache< Functor, BaseVariantTraitsType, OtherArgumentTypes >
get(const InputType &input, const OtherArgumentTypes &... ts) const (defined in wmtk::utils::metaprogramming::ReferenceWrappedFunctorReturnCache< Functor, BaseVariantTraitsType, OtherArgumentTypes >)wmtk::utils::metaprogramming::ReferenceWrappedFunctorReturnCache< Functor, BaseVariantTraitsType, OtherArgumentTypes >inline
get_id(const BaseType &input, const OtherArgumentTypes &... ts) const (defined in wmtk::utils::metaprogramming::ReferenceWrappedFunctorReturnCache< Functor, BaseVariantTraitsType, OtherArgumentTypes >)wmtk::utils::metaprogramming::ReferenceWrappedFunctorReturnCache< Functor, BaseVariantTraitsType, OtherArgumentTypes >inlineprivate
get_variant(const BaseType &input, const OtherArgumentTypes &... ts) const (defined in wmtk::utils::metaprogramming::ReferenceWrappedFunctorReturnCache< Functor, BaseVariantTraitsType, OtherArgumentTypes >)wmtk::utils::metaprogramming::ReferenceWrappedFunctorReturnCache< Functor, BaseVariantTraitsType, OtherArgumentTypes >inline
KeyType typedef (defined in wmtk::utils::metaprogramming::ReferenceWrappedFunctorReturnCache< Functor, BaseVariantTraitsType, OtherArgumentTypes >)wmtk::utils::metaprogramming::ReferenceWrappedFunctorReturnCache< Functor, BaseVariantTraitsType, OtherArgumentTypes >private
m_data (defined in wmtk::utils::metaprogramming::ReferenceWrappedFunctorReturnCache< Functor, BaseVariantTraitsType, OtherArgumentTypes >)wmtk::utils::metaprogramming::ReferenceWrappedFunctorReturnCache< Functor, BaseVariantTraitsType, OtherArgumentTypes >private
RefTupleType typedef (defined in wmtk::utils::metaprogramming::ReferenceWrappedFunctorReturnCache< Functor, BaseVariantTraitsType, OtherArgumentTypes >)wmtk::utils::metaprogramming::ReferenceWrappedFunctorReturnCache< Functor, BaseVariantTraitsType, OtherArgumentTypes >
RefVariantType typedef (defined in wmtk::utils::metaprogramming::ReferenceWrappedFunctorReturnCache< Functor, BaseVariantTraitsType, OtherArgumentTypes >)wmtk::utils::metaprogramming::ReferenceWrappedFunctorReturnCache< Functor, BaseVariantTraitsType, OtherArgumentTypes >
ReturnVariant typedef (defined in wmtk::utils::metaprogramming::ReferenceWrappedFunctorReturnCache< Functor, BaseVariantTraitsType, OtherArgumentTypes >)wmtk::utils::metaprogramming::ReferenceWrappedFunctorReturnCache< Functor, BaseVariantTraitsType, OtherArgumentTypes >
TupleType typedef (defined in wmtk::utils::metaprogramming::ReferenceWrappedFunctorReturnCache< Functor, BaseVariantTraitsType, OtherArgumentTypes >)wmtk::utils::metaprogramming::ReferenceWrappedFunctorReturnCache< Functor, BaseVariantTraitsType, OtherArgumentTypes >
TypeHelper typedef (defined in wmtk::utils::metaprogramming::ReferenceWrappedFunctorReturnCache< Functor, BaseVariantTraitsType, OtherArgumentTypes >)wmtk::utils::metaprogramming::ReferenceWrappedFunctorReturnCache< Functor, BaseVariantTraitsType, OtherArgumentTypes >
+ + + + diff --git a/classwmtk_1_1utils_1_1metaprogramming_1_1_reference_wrapped_functor_return_cache.html b/classwmtk_1_1utils_1_1metaprogramming_1_1_reference_wrapped_functor_return_cache.html new file mode 100644 index 0000000000..64acc1da87 --- /dev/null +++ b/classwmtk_1_1utils_1_1metaprogramming_1_1_reference_wrapped_functor_return_cache.html @@ -0,0 +1,142 @@ + + + + + + + +Wildmeshing Toolkit: wmtk::utils::metaprogramming::ReferenceWrappedFunctorReturnCache< Functor, BaseVariantTraitsType, OtherArgumentTypes > Class Template Reference + + + + + + + + + +
+
+ + + + + + +
+
Wildmeshing Toolkit +
+
+
+ + + + + + + + +
+
+ + +
+ +
+ + +
+
+ +
+
wmtk::utils::metaprogramming::ReferenceWrappedFunctorReturnCache< Functor, BaseVariantTraitsType, OtherArgumentTypes > Class Template Reference
+
+
+ + + + + + + + + + + + + + +

+Public Types

+using TypeHelper = ReferenceWrappedFunctorReturnType< Functor, BaseVariantTraitsType, OtherArgumentTypes... >
 
+using ReturnVariant = typename TypeHelper::type
 
+using RefVariantType = typename BaseVariantTraitsType::ReferenceVariant
 
+using BaseType = typename BaseVariantTraitsType::BaseType
 
+using TupleType = typename BaseVariantTraitsType::DerivedTypesTuple
 
+using RefTupleType = typename BaseVariantTraitsType::ReferenceTuple
 
+ + + + + + + + + +

+Public Member Functions

+template<typename InputType , typename ReturnType >
void add (ReturnType &&return_data, const InputType &input, const OtherArgumentTypes &... args)
 
+template<typename InputType >
auto get (const InputType &input, const OtherArgumentTypes &... ts) const
 
+const auto & get_variant (const BaseType &input, const OtherArgumentTypes &... ts) const
 
+ + + +

+Private Types

+using KeyType = std::tuple< const BaseType *, OtherArgumentTypes... >
 
+ + + +

+Private Member Functions

+auto get_id (const BaseType &input, const OtherArgumentTypes &... ts) const
 
+ + + +

+Private Attributes

+std::map< KeyType, ReturnVariant > m_data
 
+
The documentation for this class was generated from the following file: +
+ + + + diff --git a/dir_7094acbd2526777900e9c94c9c26ba58.html b/dir_7094acbd2526777900e9c94c9c26ba58.html new file mode 100644 index 0000000000..0de5f68340 --- /dev/null +++ b/dir_7094acbd2526777900e9c94c9c26ba58.html @@ -0,0 +1,78 @@ + + + + + + + +Wildmeshing Toolkit: /opt/wmtk-wildmeshing-actions-runner/_work/wildmeshing-toolkit/wildmeshing-toolkit/src/wmtk/utils/metaprogramming Directory Reference + + + + + + + + + +
+
+ + + + + + +
+
Wildmeshing Toolkit +
+
+
+ + + + + + + + +
+
+ + +
+ +
+ + +
+
+
+
metaprogramming Directory Reference
+
+
+
+ + + + diff --git a/dir_9f42d488f21f30bdc75c62948fa574ea.html b/dir_9f42d488f21f30bdc75c62948fa574ea.html index 5f728bb36b..7718b7d2a0 100644 --- a/dir_9f42d488f21f30bdc75c62948fa574ea.html +++ b/dir_9f42d488f21f30bdc75c62948fa574ea.html @@ -69,6 +69,10 @@
utils Directory Reference
+ + +

+Directories