aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
authorAdrian Kummerlaender2014-11-16 18:02:00 +0100
committerAdrian Kummerlaender2014-11-16 18:02:00 +0100
commit1b9a49bacf15c72c093b7e6de79b408c28e5b904 (patch)
tree1f61854d0f6de59e7f007f0796080721a90a1926
parent7d78a47828d7edfaef17df0fa15dd59e2df817be (diff)
downloadblog.kummerlaender.eu-1b9a49bacf15c72c093b7e6de79b408c28e5b904.tar
blog.kummerlaender.eu-1b9a49bacf15c72c093b7e6de79b408c28e5b904.tar.gz
blog.kummerlaender.eu-1b9a49bacf15c72c093b7e6de79b408c28e5b904.tar.bz2
blog.kummerlaender.eu-1b9a49bacf15c72c093b7e6de79b408c28e5b904.tar.lz
blog.kummerlaender.eu-1b9a49bacf15c72c093b7e6de79b408c28e5b904.tar.xz
blog.kummerlaender.eu-1b9a49bacf15c72c093b7e6de79b408c28e5b904.tar.zst
blog.kummerlaender.eu-1b9a49bacf15c72c093b7e6de79b408c28e5b904.zip
Changed markup as to not interfere with the new inline `code` style
-rw-r--r--source/00_content/articles/2014-07-11_mapping_arrays_using_tuples_in_cpp11.md4
1 files changed, 2 insertions, 2 deletions
diff --git a/source/00_content/articles/2014-07-11_mapping_arrays_using_tuples_in_cpp11.md b/source/00_content/articles/2014-07-11_mapping_arrays_using_tuples_in_cpp11.md
index 115ac27..a2fc0b3 100644
--- a/source/00_content/articles/2014-07-11_mapping_arrays_using_tuples_in_cpp11.md
+++ b/source/00_content/articles/2014-07-11_mapping_arrays_using_tuples_in_cpp11.md
@@ -2,7 +2,7 @@
During my proof-of-concept implementation of external functions enabling [XSLT based static site generation](https://github.com/KnairdA/InputXSLT) I came upon the problem of calling a template method specialized on the Nth type of a `std::tuple` specialization using the Nth element of a array-like type instance as input. This was needed to implement a generic template-based interface for implementing [Apache Xalan](http://xalan.apache.org/xalan-c/index.html) external functions. This article aims to explain the particular approach taken to solve this problem.
-While it is possible to unpack a `std::tuple` instance into individual predefined objects using `std::tie` the standard library offers no such helper template for `unpacking` an array into individual objects and calling appropriate casting methods defined by a `std::tuple` mapping type. Sadly exactly this functionality is needed so that we are able to call a `constructDocument` member method of a class derived from the [`FunctionBase`](https://github.com/KnairdA/InputXSLT/blob/master/src/function/base.h) external function interface template class using static polymorphism provided through the [curiously recurring template pattern](https://en.wikipedia.org/wiki/Curiously_Recurring_Template_Pattern). This interface template accepts the desired external function arguments as variadic template types and aims to provide the required validation and conversion boilerplate implementation. While we could recursively generate a `std::tuple` specialization instance from an array-like type using a approach simmilar to the one detailed in my article on [mapping binary structures as tuples using template metaprogramming](/article/mapping_binary_structures_as_tuples_using_template_metaprogramming) this wouldn't solve the problem of passing on the resulting values as individual objects. This is why I had to take the new approach of directly calling a template method on individual array elements using a `std::tuple` specialization as a kind of blueprint and passing the result values of this method to the `constructDocument` method as separate arguments.
+While it is possible to unpack a `std::tuple` instance into individual predefined objects using `std::tie` the standard library offers no such helper template for unpacking an array into individual objects and calling appropriate casting methods defined by a `std::tuple` mapping type. Sadly exactly this functionality is needed so that we are able to call a `constructDocument` member method of a class derived from the [`FunctionBase`](https://github.com/KnairdA/InputXSLT/blob/master/src/function/base.h) external function interface template class using static polymorphism provided through the [curiously recurring template pattern](https://en.wikipedia.org/wiki/Curiously_Recurring_Template_Pattern). This interface template accepts the desired external function arguments as variadic template types and aims to provide the required validation and conversion boilerplate implementation. While we could recursively generate a `std::tuple` specialization instance from an array-like type using a approach simmilar to the one detailed in my article on [mapping binary structures as tuples using template metaprogramming](/article/mapping_binary_structures_as_tuples_using_template_metaprogramming) this wouldn't solve the problem of passing on the resulting values as individual objects. This is why I had to take the new approach of directly calling a template method on individual array elements using a `std::tuple` specialization as a kind of blueprint and passing the result values of this method to the `constructDocument` method as separate arguments.
Extracting array elements obviously requires some way of defining the appropriate indexes and mapping the elements using a tuple blueprint additionally requires this way to be statically resolvable as one can not pass a dynamic index value to `std::tuple_element`. So the first step to fullfilling the defined requirements involved the implementation of a template based index or sequence type.
@@ -27,7 +27,7 @@ struct IndexSequence {
~~~
{: .language-cpp}
-This is achieved by the [`IndexSequence` template](https://github.com/KnairdA/InputXSLT/blob/49e2010b489ab6d5516a9abd896c67738e0dc1cc/src/support/type/sequence.h) above by recursively specializing the `Sequence` template using static recursion controlled by the standard libraries template metaprogramming utility template `std::conditional`. This means that e.g. the type `Sequence<0, 1, 2, 3>` can also be defined as `IndexSequence<4>::type`.
+This is achieved by the [`IndexSequence`](https://github.com/KnairdA/InputXSLT/blob/49e2010b489ab6d5516a9abd896c67738e0dc1cc/src/support/type/sequence.h) template above by recursively specializing the `Sequence` template using static recursion controlled by the standard libraries template metaprogramming utility template `std::conditional`. This means that e.g. the type `Sequence<0, 1, 2, 3>` can also be defined as `IndexSequence<4>::type`.
Now all that is required to accomplish the goal is instantiating the sequence type and passing it to a variadic member template as [follows](https://github.com/KnairdA/InputXSLT/blob/master/src/function/base.h):