Compute Graph Framework SDK Reference  5.8
ParameterDescriptor.hpp
Go to the documentation of this file.
1
2//
3// Notice
4// ALL NVIDIA DESIGN SPECIFICATIONS AND CODE ("MATERIALS") ARE PROVIDED "AS IS" NVIDIA MAKES
5// NO REPRESENTATIONS, WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
6// THE MATERIALS, AND EXPRESSLY DISCLAIMS ANY IMPLIED WARRANTIES OF NONINFRINGEMENT,
7// MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
8//
9// NVIDIA CORPORATION & AFFILIATES assumes no responsibility for the consequences of use of such
10// information or for any infringement of patents or other rights of third parties that may
11// result from its use. No license is granted by implication or otherwise under any patent
12// or patent rights of NVIDIA CORPORATION & AFFILIATES. No third party distribution is allowed unless
13// expressly authorized by NVIDIA. Details are subject to change without notice.
14// This code supersedes and replaces all information previously supplied.
15// NVIDIA CORPORATION & AFFILIATES products are not authorized for use as critical
16// components in life support devices or systems without express written approval of
17// NVIDIA CORPORATION & AFFILIATES.
18//
19// SPDX-FileCopyrightText: Copyright (c) 2021-2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
20// SPDX-License-Identifier: LicenseRef-NvidiaProprietary
21//
22// NVIDIA CORPORATION, its affiliates and licensors retain all intellectual
23// property and proprietary rights in and to this material, related
24// documentation and any modifications thereto. Any use, reproduction,
25// disclosure or distribution of this material and related documentation
26// without an express license agreement from NVIDIA CORPORATION or
27// its affiliates is strictly prohibited.
28//
30
31#ifndef DW_FRAMEWORK_PARAMETERDESCRIPTOR_HPP_
32#define DW_FRAMEWORK_PARAMETERDESCRIPTOR_HPP_
33
34#include <dwcgf/enum/EnumDescriptor.hpp>
35#include <dwcgf/parameter/ParameterProvider.hpp>
36#include <dw/core/container/StringView.hpp>
37#include <dw/core/language/Tuple.hpp>
38
39namespace dw
40{
41namespace framework
42{
43
44// Indices within the tuple describing constructor arguments
45// coverity[autosar_cpp14_a0_1_1_violation]
46// coverity[autosar_cpp14_m0_1_4_violation]
47static constexpr size_t PARAMETER_CONSTRUCTOR_ARGUMENT_TYPE{0U};
48// coverity[autosar_cpp14_a0_1_1_violation]
49// coverity[autosar_cpp14_m0_1_4_violation]
50static constexpr size_t PARAMETER_CONSTRUCTOR_ARGUMENT_DESCRIPTOR{1U};
51
58constexpr std::tuple<> describeConstructorArguments()
59{
60 return std::make_tuple();
61}
62
69template <
70 typename Argument1T,
71 typename Arg1>
72// Overloaded functions are provided for ease of use
73// coverity[autosar_cpp14_a2_10_5_violation]
74constexpr auto describeConstructorArguments(const Arg1&& arg1)
75{
76 return std::make_tuple(
77 std::make_tuple(
78 static_cast<Argument1T*>(nullptr),
79 std::forward<const Arg1>(arg1)));
80}
81
88template <
89 typename Argument1T, typename Argument2T,
90 typename Arg1, typename Arg2>
91// Overloaded functions are provided for ease of use
92// coverity[autosar_cpp14_a2_10_5_violation]
93constexpr auto describeConstructorArguments(const Arg1&& arg1, const Arg2&& arg2)
94{
95 return std::make_tuple(
96 std::make_tuple(
97 static_cast<Argument1T*>(nullptr),
98 std::forward<const Arg1>(arg1)),
99 std::make_tuple(
100 static_cast<Argument2T*>(nullptr),
101 std::forward<const Arg2>(arg2)));
102}
103
110template <
111 typename Argument1T, typename Argument2T, typename Argument3T,
112 typename Arg1, typename Arg2, typename Arg3>
113// Overloaded functions are provided for ease of use
114// coverity[autosar_cpp14_a2_10_5_violation]
115constexpr auto describeConstructorArguments(const Arg1&& arg1, const Arg2&& arg2, const Arg3&& arg3)
116{
117 return std::make_tuple(
118 std::make_tuple(
119 static_cast<Argument1T*>(nullptr),
120 std::forward<const Arg1>(arg1)),
121 std::make_tuple(
122 static_cast<Argument2T*>(nullptr),
123 std::forward<const Arg2>(arg2)),
124 std::make_tuple(
125 static_cast<Argument3T*>(nullptr),
126 std::forward<const Arg3>(arg3)));
127}
128
135template <
136 typename Argument1T, typename Argument2T, typename Argument3T, typename Argument4T,
137 typename Arg1, typename Arg2, typename Arg3, typename Arg4>
138// Overloaded functions are provided for ease of use
139// coverity[autosar_cpp14_a2_10_5_violation]
140constexpr auto describeConstructorArguments(const Arg1&& arg1, const Arg2&& arg2, const Arg3&& arg3, const Arg4&& arg4)
141{
142 return std::make_tuple(
143 std::make_tuple(
144 static_cast<Argument1T*>(nullptr),
145 std::forward<const Arg1>(arg1)),
146 std::make_tuple(
147 static_cast<Argument2T*>(nullptr),
148 std::forward<const Arg2>(arg2)),
149 std::make_tuple(
150 static_cast<Argument3T*>(nullptr),
151 std::forward<const Arg3>(arg3)),
152 std::make_tuple(
153 static_cast<Argument4T*>(nullptr),
154 std::forward<const Arg4>(arg4)));
155}
156
163template <
164 typename Argument1T, typename Argument2T, typename Argument3T, typename Argument4T, typename Argument5T,
165 typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5>
166// Overloaded functions are provided for ease of use
167// coverity[autosar_cpp14_a2_10_5_violation]
168constexpr auto describeConstructorArguments(const Arg1&& arg1, const Arg2&& arg2, const Arg3&& arg3, const Arg4&& arg4, const Arg5&& arg5)
169{
170 return std::make_tuple(
171 std::make_tuple(
172 static_cast<Argument1T*>(nullptr),
173 std::forward<const Arg1>(arg1)),
174 std::make_tuple(
175 static_cast<Argument2T*>(nullptr),
176 std::forward<const Arg2>(arg2)),
177 std::make_tuple(
178 static_cast<Argument3T*>(nullptr),
179 std::forward<const Arg3>(arg3)),
180 std::make_tuple(
181 static_cast<Argument4T*>(nullptr),
182 std::forward<const Arg4>(arg4)),
183 std::make_tuple(
184 static_cast<Argument5T*>(nullptr),
185 std::forward<const Arg5>(arg5)));
186}
187
194template <typename... Args>
195constexpr auto describeConstructorArgument(const Args&&... args)
196{
197 return dw::core::make_tuple(
198 std::forward<const Args>(args)...);
199}
200
201// Indices within the tuple describing parameters
202// coverity[autosar_cpp14_a0_1_1_violation]
203// coverity[autosar_cpp14_m0_1_4_violation]
204static constexpr size_t PARAMETER_TYPE_NAME{0U};
205// coverity[autosar_cpp14_a0_1_1_violation]
206// coverity[autosar_cpp14_m0_1_4_violation]
207static constexpr size_t PARAMETER_NAME{1U};
208// coverity[autosar_cpp14_a0_1_1_violation]
209// coverity[autosar_cpp14_m0_1_4_violation]
210static constexpr size_t PARAMETER_TYPE{2U};
211// coverity[autosar_cpp14_a0_1_1_violation]
212// coverity[autosar_cpp14_m0_1_4_violation]
213static constexpr size_t PARAMETER_SEMANTIC_TYPE{3U};
214// coverity[autosar_cpp14_a0_1_1_violation]
215// coverity[autosar_cpp14_m0_1_4_violation]
216static constexpr size_t PARAMETER_IS_INDEX{4U};
217// coverity[autosar_cpp14_a0_1_1_violation]
218// coverity[autosar_cpp14_m0_1_4_violation]
219static constexpr size_t PARAMETER_ARRAY_SIZE{5U};
220// coverity[autosar_cpp14_a0_1_1_violation]
221// coverity[autosar_cpp14_m0_1_4_violation]
222static constexpr size_t PARAMETER_MEMBER_PTRS{6U};
223// coverity[autosar_cpp14_a0_1_1_violation]
224// coverity[autosar_cpp14_m0_1_4_violation]
225static constexpr size_t PARAMETER_DEFAULT_VALUE{7U};
226
227} // namespace framework
228} // namespace dw
229
230#define DW_PARAMETER_TYPE_NAME_STRING_VIEW(TYPE_NAME_STR) TYPE_NAME_STR##_sv
231#define DW_DESCRIBE_PARAMETER(TYPE_NAME, args...) dw::framework::describeParameter<TYPE_NAME, TYPE_NAME>(DW_PARAMETER_TYPE_NAME_STRING_VIEW(#TYPE_NAME), ##args)
232#define DW_DESCRIBE_PARAMETER_WITH_SEMANTIC(TYPE_NAME, SEMANTIC_TYPE_NAME, args...) dw::framework::describeParameter<TYPE_NAME, SEMANTIC_TYPE_NAME>(DW_PARAMETER_TYPE_NAME_STRING_VIEW(#TYPE_NAME), ##args)
233
234namespace dw
235{
236namespace framework
237{
238
247template <typename T, typename S, typename... MemberPointers>
248constexpr auto describeParameter(
249 dw::core::StringView const&& typeName, dw::core::StringView const&& parameterName, const MemberPointers&&... memberPointers)
250{
251 return std::make_tuple(
252 std::move(typeName),
253 std::move(parameterName),
254 static_cast<T*>(nullptr),
255 static_cast<S*>(nullptr),
256 false,
257 static_cast<size_t>(0),
258 std::move(
259 std::make_tuple<const MemberPointers...>(std::forward<const MemberPointers>(memberPointers)...)));
260}
261
262} // namespace framework
263} // namespace dw
264
265#define DW_DESCRIBE_ABSTRACT_PARAMETER(TYPE_NAME, args...) dw::framework::describeAbstractParameter<TYPE_NAME>(DW_PARAMETER_TYPE_NAME_STRING_VIEW(#TYPE_NAME), ##args)
266#define DW_DESCRIBE_ABSTRACT_ARRAY_PARAMETER(TYPE_NAME, args...) dw::framework::describeAbstractArrayParameter<TYPE_NAME>(DW_PARAMETER_TYPE_NAME_STRING_VIEW(#TYPE_NAME), ##args)
267
268namespace dw
269{
270namespace framework
271{
272
278template <typename T>
279constexpr auto describeAbstractParameter(
280 dw::core::StringView const&& typeName, dw::core::StringView const&& parameterName)
281{
282 return std::make_tuple(
283 std::move(typeName),
284 std::move(parameterName),
285 static_cast<T*>(nullptr),
286 static_cast<T*>(nullptr),
287 false,
288 static_cast<size_t>(0));
289}
290
296template <typename T>
297constexpr auto describeAbstractArrayParameter(
298 dw::core::StringView const&& typeName, dw::core::StringView const&& parameterName, size_t arraySize)
299{
300 return std::make_tuple(
301 std::move(typeName),
302 std::move(parameterName),
303 static_cast<T*>(nullptr),
304 static_cast<T*>(nullptr),
305 false,
306 arraySize);
307}
308
309} // namespace framework
310} // namespace dw
311
312#define DW_DESCRIBE_INDEX_PARAMETER(TYPE_NAME, args...) dw::framework::describeIndexParameter<TYPE_NAME, TYPE_NAME>(DW_PARAMETER_TYPE_NAME_STRING_VIEW(#TYPE_NAME), ##args)
313#define DW_DESCRIBE_INDEX_PARAMETER_WITH_SEMANTIC(TYPE_NAME, SEMANTIC_TYPE_NAME, args...) dw::framework::describeIndexParameter<TYPE_NAME, SEMANTIC_TYPE_NAME>(DW_PARAMETER_TYPE_NAME_STRING_VIEW(#TYPE_NAME), ##args)
314
315namespace dw
316{
317namespace framework
318{
319
326template <typename T, typename S, typename... MemberPointers>
327constexpr auto describeIndexParameter(
328 dw::core::StringView const&& typeName, dw::core::StringView const&& parameterName, const MemberPointers&&... memberPointers)
329{
330 return std::make_tuple(
331 std::move(typeName),
332 std::move(parameterName),
333 static_cast<T*>(nullptr),
334 static_cast<S*>(nullptr),
335 true,
336 static_cast<size_t>(0),
337 std::move(
338 std::make_tuple<const MemberPointers...>(std::forward<const MemberPointers>(memberPointers)...)));
339}
340
341} // namespace framework
342} // namespace dw
343
344#define DW_DESCRIBE_ARRAY_PARAMETER(TYPE_NAME, args...) dw::framework::describeArrayParameter<TYPE_NAME, TYPE_NAME>(DW_PARAMETER_TYPE_NAME_STRING_VIEW(#TYPE_NAME), ##args)
345#define DW_DESCRIBE_ARRAY_PARAMETER_WITH_SEMANTIC(TYPE_NAME, SEMANTIC_TYPE_NAME, args...) dw::framework::describeArrayParameter<TYPE_NAME, SEMANTIC_TYPE_NAME>(DW_PARAMETER_TYPE_NAME_STRING_VIEW(#TYPE_NAME), ##args)
346
347namespace dw
348{
349namespace framework
350{
351
357template <typename T, typename S, typename... MemberPointers>
358constexpr auto describeArrayParameter(
359 dw::core::StringView const&& typeName, dw::core::StringView const&& parameterName, size_t arraySize, const MemberPointers&&... memberPointers)
360{
361 return std::make_tuple(
362 std::move(typeName),
363 std::move(parameterName),
364 static_cast<T*>(nullptr),
365 static_cast<S*>(nullptr),
366 false,
367 arraySize,
368 std::move(
369 std::make_tuple<const MemberPointers...>(std::forward<const MemberPointers>(memberPointers)...)));
370}
371
372} // namespace framework
373} // namespace dw
374
375#define DW_DESCRIBE_UNNAMED_PARAMETER(TYPE_NAME, args...) dw::framework::describeUnnamedParameter<TYPE_NAME, TYPE_NAME>(DW_PARAMETER_TYPE_NAME_STRING_VIEW(#TYPE_NAME), ##args)
376#define DW_DESCRIBE_UNNAMED_PARAMETER_WITH_SEMANTIC(TYPE_NAME, SEMANTIC_TYPE_NAME, args...) dw::framework::describeUnnamedParameter<TYPE_NAME, SEMANTIC_TYPE_NAME>(DW_PARAMETER_TYPE_NAME_STRING_VIEW(#TYPE_NAME), ##args)
377
378namespace dw
379{
380namespace framework
381{
382
389template <typename T, typename S, typename... MemberPointers>
390constexpr auto describeUnnamedParameter(
391 dw::core::StringView const&& typeName, const MemberPointers&&... memberPointers)
392{
393 return describeParameter<T, S>(
394 std::move(typeName),
395 ""_sv,
396 std::forward<const MemberPointers>(memberPointers)...);
397}
398
399} // namespace framework
400} // namespace dw
401
402#define DW_DESCRIBE_UNNAMED_ARRAY_PARAMETER(TYPE_NAME, args...) dw::framework::describeUnnamedArrayParameter<TYPE_NAME, TYPE_NAME>(DW_PARAMETER_TYPE_NAME_STRING_VIEW(#TYPE_NAME), ##args)
403#define DW_DESCRIBE_UNNAMED_ARRAY_PARAMETER_WITH_SEMANTIC(TYPE_NAME, SEMANTIC_TYPE_NAME, args...) dw::framework::describeUnnamedArrayParameter<TYPE_NAME, SEMANTIC_TYPE_NAME>(DW_PARAMETER_TYPE_NAME_STRING_VIEW(#TYPE_NAME), ##args)
404
405namespace dw
406{
407namespace framework
408{
409
416template <typename T, typename S, typename... MemberPointers>
417constexpr auto describeUnnamedArrayParameter(
418 dw::core::StringView const&& typeName, size_t arraySize, const MemberPointers&&... memberPointers)
419{
420 return describeArrayParameter<T, S>(
421 std::move(typeName),
422 ""_sv,
423 arraySize,
424 std::forward<const MemberPointers>(memberPointers)...);
425}
426
427} // namespace framework
428} // namespace dw
429
430#define DW_DESCRIBE_PARAMETER_WITH_DEFAULT(TYPE_NAME, args...) dw::framework::describeParameterWithDefault<TYPE_NAME, TYPE_NAME>(DW_PARAMETER_TYPE_NAME_STRING_VIEW(#TYPE_NAME), ##args)
431
432namespace dw
433{
434namespace framework
435{
436
442template <typename T, typename S, typename... MemberPointers>
443constexpr auto describeParameterWithDefault(
444 dw::core::StringView const&& typeName, dw::core::StringView const&& parameterName, T defaultValue, const MemberPointers&&... memberPointers)
445{
446 return std::make_tuple(
447 std::move(typeName),
448 std::move(parameterName),
449 static_cast<T*>(nullptr),
450 static_cast<S*>(nullptr),
451 false,
452 static_cast<size_t>(0),
453 std::move(
454 std::make_tuple<const MemberPointers...>(std::forward<const MemberPointers>(memberPointers)...)),
455 std::move(defaultValue));
456}
457
458} // namespace framework
459} // namespace dw
460
461#define DW_DESCRIBE_ARRAY_PARAMETER_WITH_DEFAULT(TYPE_NAME, args...) dw::framework::describeArrayParameterWithDefault<TYPE_NAME, TYPE_NAME>(DW_PARAMETER_TYPE_NAME_STRING_VIEW(#TYPE_NAME), ##args)
462
463namespace dw
464{
465namespace framework
466{
467
473template <typename T, typename S, size_t ArraySize, typename... MemberPointers>
474constexpr auto describeArrayParameterWithDefault(
475 dw::core::StringView const&& typeName, dw::core::StringView const&& parameterName, std::array<T, ArraySize> defaultValue, const MemberPointers&&... memberPointers)
476{
477 return std::make_tuple(
478 std::move(typeName),
479 std::move(parameterName),
480 static_cast<T*>(nullptr),
481 static_cast<S*>(nullptr),
482 false,
483 ArraySize,
484 std::move(
485 std::make_tuple<const MemberPointers...>(std::forward<const MemberPointers>(memberPointers)...)),
486 std::move(defaultValue));
487}
488
490template <typename NodeT>
491constexpr auto describeParameters()
492{
493 return NodeT::describeParameters();
494}
495
496namespace detail
497{
498
500template <
501 typename Param, typename MemberPtr,
502 typename std::enable_if_t<std::tuple_size<Param>() <= PARAMETER_DEFAULT_VALUE, void>* = nullptr>
503void populateDefault(const Param& param, MemberPtr& memberPtr)
504{
505 static_cast<void>(param);
506 static_cast<void>(memberPtr);
507}
508
510template <
511 typename Param, typename MemberPtr,
512 typename std::enable_if_t<PARAMETER_DEFAULT_VALUE<std::tuple_size<Param>(), void>* = nullptr>
513 // TODO(dwplc): FP -- The specific specialization of this templated function is selected by enable_if
514 // coverity[autosar_cpp14_a2_10_5_violation]
515 void populateDefault(const Param& param, MemberPtr& memberPtr)
516{
517 auto defaultValue = std::get<PARAMETER_DEFAULT_VALUE>(param);
518 memberPtr = defaultValue;
519}
520
522template <
523 typename Param, typename MemberPtr,
524 typename std::enable_if_t<std::tuple_size<Param>() <= PARAMETER_DEFAULT_VALUE, void>* = nullptr>
525void populateArrayDefault(const Param& param, MemberPtr& memberPtr, size_t index)
526{
527 static_cast<void>(param);
528 static_cast<void>(memberPtr);
529 static_cast<void>(index);
530}
531
533template <
534 typename Param, typename MemberPtr,
535 typename std::enable_if_t<PARAMETER_DEFAULT_VALUE<std::tuple_size<Param>(), void>* = nullptr>
536 // TODO(dwplc): FP -- The specific specialization of this templated function is selected by enable_if
537 // coverity[autosar_cpp14_a2_10_5_violation]
538 void populateArrayDefault(const Param& param, MemberPtr& memberPtr, size_t index)
539{
540 auto defaultValue = std::get<PARAMETER_DEFAULT_VALUE>(param);
541 memberPtr[index] = defaultValue[index];
542}
543
545template <
546 size_t MemberIndex, typename ArgType, typename MemberPtrs,
547 typename std::enable_if_t<std::tuple_size<MemberPtrs>() == 0, void>* = nullptr>
548auto& getMemberPtr(ArgType& arg, MemberPtrs memberPtrs)
549{
550 static_cast<void>(memberPtrs);
551 return arg;
552}
553
555template <
556 size_t MemberIndex, typename ArgType, typename MemberPtrs,
557 typename std::enable_if_t<MemberIndex + 1 == std::tuple_size<MemberPtrs>(), void>* = nullptr>
558// TODO(dwplc): FP -- The specific specialization of this templated function is selected by enable_if
559// coverity[autosar_cpp14_a2_10_5_violation]
560auto& getMemberPtr(ArgType& arg, MemberPtrs memberPtrs)
561{
562 auto member = std::get<MemberIndex>(memberPtrs);
563 return arg.*member;
564}
565
567template <
568 size_t MemberIndex, typename ArgType, typename MemberPtrs,
569 typename std::enable_if_t<MemberIndex + 1 < std::tuple_size<MemberPtrs>(), void>* = nullptr>
570// TODO(dwplc): FP -- The specific specialization of this templated function is selected by enable_if
571// coverity[autosar_cpp14_a2_10_5_violation]
572auto& getMemberPtr(ArgType& arg, MemberPtrs memberPtrs)
573{
574 auto& member = std::get<MemberIndex>(memberPtrs);
575 auto& m = arg.*member;
576 return getMemberPtr<MemberIndex + 1>(m, memberPtrs);
577}
578
580template <typename NodeT, size_t ConstructorParameterIndex>
581constexpr size_t constructorArgumentParameterSize()
582{
583 return dw::core::tuple_size<
584 std::tuple_element_t<
585 PARAMETER_CONSTRUCTOR_ARGUMENT_DESCRIPTOR,
586 std::tuple_element_t<
587 ConstructorParameterIndex,
588 decltype(describeParameters<NodeT>())>>>();
589}
590
592template <
593 typename NodeT, size_t ConstructorParameterIndex, size_t ParamIndex, typename ArgType,
594 typename std::enable_if_t<ParamIndex == constructorArgumentParameterSize<NodeT, ConstructorParameterIndex>(), void>* = nullptr>
595void populateParametersRecursion(const ParameterProvider& provider, ArgType& arg)
596{
597 static_cast<void>(arg);
598 static_cast<void>(provider);
599}
600
602template <typename NodeT, size_t ConstructorParameterIndex, size_t ParamIndex>
603constexpr bool isIndexParameter()
604{
605 constexpr auto param = dw::core::get<ParamIndex>(
606 std::get<PARAMETER_CONSTRUCTOR_ARGUMENT_DESCRIPTOR>(
607 std::get<ConstructorParameterIndex>(describeParameters<NodeT>())));
608 return std::get<PARAMETER_IS_INDEX>(param);
609}
610
612template <typename NodeT, size_t ConstructorParameterIndex, size_t ParamIndex>
613constexpr bool isArrayParameter()
614{
615 constexpr auto param = dw::core::get<ParamIndex>(
616 std::get<PARAMETER_CONSTRUCTOR_ARGUMENT_DESCRIPTOR>(
617 std::get<ConstructorParameterIndex>(describeParameters<NodeT>())));
618 constexpr size_t arraySize = std::get<
619 PARAMETER_ARRAY_SIZE>(param);
620 return arraySize > 0;
621}
622
624template <typename NodeT, size_t ConstructorParameterIndex, size_t ParamIndex>
625constexpr bool isAbstractParameter()
626{
627 constexpr auto param = dw::core::get<ParamIndex>(
628 std::get<PARAMETER_CONSTRUCTOR_ARGUMENT_DESCRIPTOR>(
629 std::get<ConstructorParameterIndex>(describeParameters<NodeT>())));
630 return std::tuple_size<decltype(param)>() <= PARAMETER_MEMBER_PTRS;
631}
632
634template <
635 typename NodeT, size_t ConstructorParameterIndex, size_t ParamIndex, typename ArgType,
636 typename std::enable_if_t<isAbstractParameter<NodeT, ConstructorParameterIndex, ParamIndex>(), void>* = nullptr>
637// TODO(dwplc): FP -- The specific specialization of this templated function is selected by enable_if
638// coverity[autosar_cpp14_a2_10_5_violation]
639void populateParameter(const ParameterProvider& provider, ArgType& arg)
640{
641 static_cast<void>(arg);
642 static_cast<void>(provider);
643}
644
650template <
651 typename NodeT, size_t ConstructorParameterIndex, size_t ParamIndex, typename ArgType,
652 typename std::enable_if_t<!isAbstractParameter<NodeT, ConstructorParameterIndex, ParamIndex>() && !isArrayParameter<NodeT, ConstructorParameterIndex, ParamIndex>() && !isIndexParameter<NodeT, ConstructorParameterIndex, ParamIndex>(), void>* = nullptr>
653// TODO(dwplc): FP -- The specific specialization of this templated function is selected by enable_if
654// coverity[autosar_cpp14_a2_10_5_violation]
655void populateParameter(const ParameterProvider& provider, ArgType& arg)
656{
657 constexpr auto param = dw::core::get<ParamIndex>(
658 std::get<PARAMETER_CONSTRUCTOR_ARGUMENT_DESCRIPTOR>(
659 std::get<ConstructorParameterIndex>(describeParameters<NodeT>())));
660
661 using DataType = std::remove_pointer_t<
662 std::tuple_element_t<
663 PARAMETER_TYPE, decltype(param)>>;
664 using SemanticDataType = std::remove_pointer_t<
665 std::tuple_element_t<
666 PARAMETER_SEMANTIC_TYPE, decltype(param)>>;
667
668 DataType& memberPtr = getMemberPtr<0>(arg, std::get<PARAMETER_MEMBER_PTRS>(param));
669 bool hadParameter = provider.getOptional<SemanticDataType, DataType>(std::get<PARAMETER_NAME>(param), &memberPtr);
670 if (!hadParameter)
671 {
672 populateDefault(param, memberPtr);
673 }
674}
675
681template <
682 typename NodeT, size_t ConstructorParameterIndex, size_t ParamIndex, typename ArgType,
683 typename std::enable_if_t<!isAbstractParameter<NodeT, ConstructorParameterIndex, ParamIndex>() && !isArrayParameter<NodeT, ConstructorParameterIndex, ParamIndex>() && isIndexParameter<NodeT, ConstructorParameterIndex, ParamIndex>(), void>* = nullptr>
684// TODO(dwplc): FP -- The specific specialization of this templated function is selected by enable_if
685// coverity[autosar_cpp14_a2_10_5_violation]
686void populateParameter(const ParameterProvider& provider, ArgType& arg)
687{
688 constexpr auto param = dw::core::get<ParamIndex>(
689 std::get<PARAMETER_CONSTRUCTOR_ARGUMENT_DESCRIPTOR>(
690 std::get<ConstructorParameterIndex>(describeParameters<NodeT>())));
691
692 using DataType = std::remove_pointer_t<
693 std::tuple_element_t<
694 PARAMETER_TYPE, decltype(param)>>;
695 using SemanticDataType = std::remove_pointer_t<
696 std::tuple_element_t<
697 PARAMETER_SEMANTIC_TYPE, decltype(param)>>;
698 DataType& memberPtr = getMemberPtr<0>(arg, std::get<PARAMETER_MEMBER_PTRS>(param));
699
700 size_t index = static_cast<size_t>(-1);
701 bool hadParameter = provider.getOptional<size_t, size_t>(std::get<PARAMETER_NAME>(param), &index);
702 if (hadParameter)
703 {
704 hadParameter = provider.getOptional<SemanticDataType, DataType>("", index, &memberPtr);
705 }
706 if (!hadParameter)
707 {
708 populateDefault(param, memberPtr);
709 }
710}
711
717template <
718 typename NodeT, size_t ConstructorParameterIndex, size_t ParamIndex, typename ArgType,
719 typename std::enable_if_t<!isAbstractParameter<NodeT, ConstructorParameterIndex, ParamIndex>() && isArrayParameter<NodeT, ConstructorParameterIndex, ParamIndex>(), void>* = nullptr>
720// TODO(dwplc): FP -- The specific specialization of this templated function is selected by enable_if
721// coverity[autosar_cpp14_a2_10_5_violation]
722void populateParameter(const ParameterProvider& provider, ArgType& arg)
723{
724 constexpr auto param = dw::core::get<ParamIndex>(
725 std::get<PARAMETER_CONSTRUCTOR_ARGUMENT_DESCRIPTOR>(
726 std::get<ConstructorParameterIndex>(describeParameters<NodeT>())));
727
728 using DataType = std::remove_pointer_t<
729 std::tuple_element_t<
730 PARAMETER_TYPE, decltype(param)>>;
731 using SemanticDataType = std::remove_pointer_t<
732 std::tuple_element_t<
733 PARAMETER_SEMANTIC_TYPE, decltype(param)>>;
734
735 constexpr size_t arraySize = std::get<PARAMETER_ARRAY_SIZE>(
736 param);
737
738 DataType(&memberPtr)[arraySize] = getMemberPtr<0>(arg, std::get<PARAMETER_MEMBER_PTRS>(param));
739 for (size_t i = 0; i < arraySize; ++i)
740 {
741 bool hadParameter = provider.getOptional<SemanticDataType, DataType>(std::get<PARAMETER_NAME>(param), i, &memberPtr[i]);
742 if (!hadParameter)
743 {
744 populateArrayDefault(param, memberPtr, i);
745 }
746 }
747}
748
750template <
751 typename NodeT, size_t ConstructorParameterIndex, size_t ParamIndex, typename ArgType,
752 typename std::enable_if_t<ParamIndex<constructorArgumentParameterSize<NodeT, ConstructorParameterIndex>(), void>* = nullptr>
753 // TODO(dwplc): FP -- The specific specialization of this templated function is selected by enable_if
754 // coverity[autosar_cpp14_a2_10_5_violation]
755 void populateParametersRecursion(const ParameterProvider& provider, ArgType& arg)
756{
757 populateParameter<NodeT, ConstructorParameterIndex, ParamIndex>(provider, arg);
758
759 populateParametersRecursion<NodeT, ConstructorParameterIndex, ParamIndex + 1>(provider, arg);
760}
761
767template <typename NodeT, size_t ConstructorParameterIndex, typename ArgType>
768// TODO(dwplc): FP -- The other populateParameters() functions are defined in the parent namespace
769// coverity[autosar_cpp14_a2_10_5_violation]
770void populateParameters(const ParameterProvider& provider, ArgType& arg)
771{
772 try
773 {
774 populateParametersRecursion<NodeT, ConstructorParameterIndex, 0>(provider, arg);
775 }
776 catch (Exception& e)
777 {
778 throw Exception(e.status(), "Exception while populating parameters of mangled node type ", typeid(NodeT).name(), ": ", e.messageStr());
779 }
780}
781
782} // namespace detail
783
785template <
786 typename NodeT,
787 class ConstructorArguments,
788 typename std::enable_if_t<std::tuple_size<ConstructorArguments>() == 1, void>* = nullptr>
789// TODO(dwplc): FP -- The specific specialization of this templated function is selected by enable_if
790// coverity[autosar_cpp14_a2_10_5_violation]
791void populateParameters(ConstructorArguments& constructorArguments, const ParameterProvider& provider)
792{
793 auto& arg0 = std::get<0>(constructorArguments);
794 detail::populateParameters<NodeT, 0>(provider, arg0);
795}
796
798template <
799 typename NodeT,
800 class ConstructorArguments,
801 typename std::enable_if_t<std::tuple_size<ConstructorArguments>() == 2, void>* = nullptr>
802// TODO(dwplc): FP -- The specific specialization of this templated function is selected by enable_if
803// coverity[autosar_cpp14_a2_10_5_violation]
804void populateParameters(ConstructorArguments& constructorArguments, const ParameterProvider& provider)
805{
806 auto& arg0 = std::get<0>(constructorArguments);
807 detail::populateParameters<NodeT, 0>(provider, arg0);
808 auto& arg1 = std::get<1>(constructorArguments);
809 detail::populateParameters<NodeT, 1>(provider, arg1);
810}
811
813template <
814 typename NodeT,
815 class ConstructorArguments,
816 typename std::enable_if_t<std::tuple_size<ConstructorArguments>() == 3, void>* = nullptr>
817// TODO(dwplc): FP -- The specific specialization of this templated function is selected by enable_if
818// coverity[autosar_cpp14_a2_10_5_violation]
819void populateParameters(ConstructorArguments& constructorArguments, const ParameterProvider& provider)
820{
821 auto& arg0 = std::get<0>(constructorArguments);
822 detail::populateParameters<NodeT, 0>(provider, arg0);
823 auto& arg1 = std::get<1>(constructorArguments);
824 detail::populateParameters<NodeT, 1>(provider, arg1);
825 auto& arg2 = std::get<2>(constructorArguments);
826 detail::populateParameters<NodeT, 2>(provider, arg2);
827}
828
830template <
831 typename NodeT,
832 class ConstructorArguments,
833 typename std::enable_if_t<std::tuple_size<ConstructorArguments>() == 4, void>* = nullptr>
834// TODO(dwplc): FP -- The specific specialization of this templated function is selected by enable_if
835// coverity[autosar_cpp14_a2_10_5_violation]
836void populateParameters(ConstructorArguments& constructorArguments, const ParameterProvider& provider)
837{
838 auto& arg0 = std::get<0>(constructorArguments);
839 detail::populateParameters<NodeT, 0>(provider, arg0);
840 auto& arg1 = std::get<1>(constructorArguments);
841 detail::populateParameters<NodeT, 1>(provider, arg1);
842 auto& arg2 = std::get<2>(constructorArguments);
843 detail::populateParameters<NodeT, 2>(provider, arg2);
844 auto& arg3 = std::get<3>(constructorArguments);
845 detail::populateParameters<NodeT, 3>(provider, arg3);
846}
847
849template <
850 typename NodeT,
851 class ConstructorArguments,
852 typename std::enable_if_t<std::tuple_size<ConstructorArguments>() == 5, void>* = nullptr>
853// TODO(dwplc): FP -- The specific specialization of this templated function is selected by enable_if
854// coverity[autosar_cpp14_a2_10_5_violation]
855void populateParameters(ConstructorArguments& constructorArguments, const ParameterProvider& provider)
856{
857 auto& arg0 = std::get<0>(constructorArguments);
858 detail::populateParameters<NodeT, 0>(provider, arg0);
859 auto& arg1 = std::get<1>(constructorArguments);
860 detail::populateParameters<NodeT, 1>(provider, arg1);
861 auto& arg2 = std::get<2>(constructorArguments);
862 detail::populateParameters<NodeT, 2>(provider, arg2);
863 auto& arg3 = std::get<3>(constructorArguments);
864 detail::populateParameters<NodeT, 3>(provider, arg3);
865 auto& arg4 = std::get<4>(constructorArguments);
866 detail::populateParameters<NodeT, 4>(provider, arg4);
867}
868
869namespace detail
870{
871
872// Get the Number of constructor arguments of the passed node.
873template <typename NodeT>
874constexpr std::size_t parameterConstructorArgumentSize()
875{
876 return std::tuple_size<decltype(describeParameters<NodeT>())>::value;
877}
878
880template <
881 typename NodeT, size_t ConstructorArgumentIndex,
882 typename std::enable_if_t<ConstructorArgumentIndex == parameterConstructorArgumentSize<NodeT>(), void>* = nullptr>
883// TODO(dwplc): FP -- The specific specialization of this templated function is selected by enable_if
884// coverity[autosar_cpp14_a2_10_5_violation]
885auto createConstructorArguments()
886{
887 return std::make_tuple();
888}
889
891template <
892 typename NodeT, size_t ConstructorArgumentIndex,
893 typename std::enable_if_t<ConstructorArgumentIndex<parameterConstructorArgumentSize<NodeT>(), void>* = nullptr>
894 // TODO(dwplc): FP -- The specific specialization of this templated function is selected by enable_if
895 // coverity[autosar_cpp14_a2_10_5_violation]
896 auto createConstructorArguments()
897{
898 using NodeParams = decltype(describeParameters<NodeT>());
899
900 using ConstructorParameter = std::tuple_element_t<ConstructorArgumentIndex, NodeParams>;
901 using ArgType = std::remove_pointer_t<
902 typename std::tuple_element_t<PARAMETER_CONSTRUCTOR_ARGUMENT_TYPE, ConstructorParameter>>;
903 ArgType arg{};
904
905 return std::tuple_cat(std::make_tuple(arg), createConstructorArguments<NodeT, ConstructorArgumentIndex + 1>());
906}
907
908} // namespace detail
909
911template <typename NodeT>
912auto createConstructorArguments()
913{
914 return detail::createConstructorArguments<NodeT, 0>();
915}
916
917namespace detail
918{
919
921template <class T, class Tuple, size_t... Is>
922// TODO(dwplc): FP -- The other parameterSize() functions are defined in a namespace
923// coverity[autosar_cpp14_a2_10_5_violation]
924auto makeUniqueFromTuple(const Tuple&& tuple, std::index_sequence<Is...>) -> std::unique_ptr<T>
925{
926 return std::unique_ptr<T>(new T{std::get<Is>(std::move(tuple))...});
927}
928}
929
931template <typename NodeT, class ConstructorArguments>
932auto makeUniqueFromTuple(const ConstructorArguments&& constructorArguments) -> std::unique_ptr<NodeT>
933{
934 return detail::makeUniqueFromTuple<NodeT>(
935 std::move(constructorArguments),
936 std::make_index_sequence<std::tuple_size<std::decay_t<ConstructorArguments>>::value>{});
937}
938
947template <typename NodeT>
948auto create(const ParameterProvider& provider) -> std::unique_ptr<NodeT>
949{
950 auto constructorArguments = createConstructorArguments<NodeT>();
951 populateParameters<NodeT>(constructorArguments, provider);
952 return makeUniqueFromTuple<NodeT>(std::move(constructorArguments));
953}
954
955// Number of parameters (sum across all constructor arguments)
956namespace detail
957{
958
960template <
961 typename NodeT, size_t ConstructorArgumentIndex,
962 typename std::enable_if_t<ConstructorArgumentIndex == parameterConstructorArgumentSize<NodeT>(), void>* = nullptr>
963// TODO(dwplc): FP -- The specific specialization of this templated function is selected by enable_if
964// coverity[autosar_cpp14_a2_10_5_violation]
965constexpr std::size_t parameterSize()
966{
967 return 0;
968}
969
971template <
972 typename NodeT, size_t ConstructorArgumentIndex,
973 typename std::enable_if_t<ConstructorArgumentIndex<parameterConstructorArgumentSize<NodeT>(), void>* = nullptr>
974 // TODO(dwplc): FP -- The specific specialization of this templated function is selected by enable_if
975 // coverity[autosar_cpp14_a2_10_5_violation]
976 constexpr std::size_t parameterSize()
977{
978 return constructorArgumentParameterSize<NodeT, ConstructorArgumentIndex>() + parameterSize<NodeT, ConstructorArgumentIndex + 1>();
979}
980
981} // namespace detail
982
984// TODO(dwplc): FP -- The other parameterSize() functions are defined in a namespace
985// coverity[autosar_cpp14_a2_10_5_violation]
986template <typename NodeT>
987constexpr std::size_t parameterSize()
988{
989 return detail::parameterSize<NodeT, 0>();
990}
991
992} // namespace framework
993} // namespace dw
994
995#endif // DW_FRAMEWORK_PARAMETERDESCRIPTOR_HPP_
dw::framework::ParameterProvider
The interface to access parameter values identified by name and/or (semantic) type.
Definition: ParameterProvider.hpp:52
dw::framework::describeArrayParameterWithDefault
constexpr auto describeArrayParameterWithDefault(dw::core::StringView const &&typeName, dw::core::StringView const &&parameterName, std::array< T, ArraySize > defaultValue, const MemberPointers &&... memberPointers)
Definition: ParameterDescriptor.hpp:474
dw::framework::describeAbstractParameter
constexpr auto describeAbstractParameter(dw::core::StringView const &&typeName, dw::core::StringView const &&parameterName)
Definition: ParameterDescriptor.hpp:279
dw::framework::PARAMETER_SEMANTIC_TYPE
static constexpr size_t PARAMETER_SEMANTIC_TYPE
Definition: ParameterDescriptor.hpp:213
dw::framework::makeUniqueFromTuple
auto makeUniqueFromTuple(const ConstructorArguments &&constructorArguments) -> std::unique_ptr< NodeT >
Instantiate a node using the passed constructor arguments.
Definition: ParameterDescriptor.hpp:932
dw::framework::PARAMETER_DEFAULT_VALUE
static constexpr size_t PARAMETER_DEFAULT_VALUE
Definition: ParameterDescriptor.hpp:225
dw::framework::describeConstructorArguments
constexpr std::tuple describeConstructorArguments()
Definition: ParameterDescriptor.hpp:58
dw::framework::describeUnnamedArrayParameter
constexpr auto describeUnnamedArrayParameter(dw::core::StringView const &&typeName, size_t arraySize, const MemberPointers &&... memberPointers)
Definition: ParameterDescriptor.hpp:417
dw::framework::PARAMETER_MEMBER_PTRS
static constexpr size_t PARAMETER_MEMBER_PTRS
Definition: ParameterDescriptor.hpp:222
dw::framework::PARAMETER_NAME
static constexpr size_t PARAMETER_NAME
Definition: ParameterDescriptor.hpp:207
dw::framework::describeUnnamedParameter
constexpr auto describeUnnamedParameter(dw::core::StringView const &&typeName, const MemberPointers &&... memberPointers)
Definition: ParameterDescriptor.hpp:390
dw::framework::PARAMETER_CONSTRUCTOR_ARGUMENT_DESCRIPTOR
static constexpr size_t PARAMETER_CONSTRUCTOR_ARGUMENT_DESCRIPTOR
Definition: ParameterDescriptor.hpp:50
dw::framework::describeIndexParameter
constexpr auto describeIndexParameter(dw::core::StringView const &&typeName, dw::core::StringView const &&parameterName, const MemberPointers &&... memberPointers)
Definition: ParameterDescriptor.hpp:327
dw::framework::createConstructorArguments
auto createConstructorArguments()
Create a tuple of constructor argument needed by the constructor of the passed node.
Definition: ParameterDescriptor.hpp:912
dw::framework::PARAMETER_ARRAY_SIZE
static constexpr size_t PARAMETER_ARRAY_SIZE
Definition: ParameterDescriptor.hpp:219
dw::framework::describeParameter
constexpr auto describeParameter(dw::core::StringView const &&typeName, dw::core::StringView const &&parameterName, const MemberPointers &&... memberPointers)
Definition: ParameterDescriptor.hpp:248
dw::framework::describeAbstractArrayParameter
constexpr auto describeAbstractArrayParameter(dw::core::StringView const &&typeName, dw::core::StringView const &&parameterName, size_t arraySize)
Definition: ParameterDescriptor.hpp:297
dw::framework::populateParameters
void populateParameters(ConstructorArguments &constructorArguments, const ParameterProvider &provider)
Populate the constructor arguments using values from the parameter provider.
Definition: ParameterDescriptor.hpp:791
dw::framework::describeParameters
constexpr auto describeParameters()
Get described parameters for the passed node.
Definition: ParameterDescriptor.hpp:491
dw::framework::PARAMETER_IS_INDEX
static constexpr size_t PARAMETER_IS_INDEX
Definition: ParameterDescriptor.hpp:216
dw::framework::describeConstructorArgument
constexpr auto describeConstructorArgument(const Args &&... args)
Definition: ParameterDescriptor.hpp:195
dw::framework::parameterSize
constexpr std::size_t parameterSize()
Get the number of parameters for a given node.
Definition: ParameterDescriptor.hpp:987
dw::framework::describeArrayParameter
constexpr auto describeArrayParameter(dw::core::StringView const &&typeName, dw::core::StringView const &&parameterName, size_t arraySize, const MemberPointers &&... memberPointers)
Definition: ParameterDescriptor.hpp:358
dw::framework::describeParameterWithDefault
constexpr auto describeParameterWithDefault(dw::core::StringView const &&typeName, dw::core::StringView const &&parameterName, T defaultValue, const MemberPointers &&... memberPointers)
Definition: ParameterDescriptor.hpp:443
dw::framework::create
auto create(const ParameterProvider &provider) -> std::unique_ptr< NodeT >
Definition: ParameterDescriptor.hpp:948
dw::framework::PARAMETER_TYPE
static constexpr size_t PARAMETER_TYPE
Definition: ParameterDescriptor.hpp:210
dw::framework::PARAMETER_TYPE_NAME
static constexpr size_t PARAMETER_TYPE_NAME
Definition: ParameterDescriptor.hpp:204
dw::framework::PARAMETER_CONSTRUCTOR_ARGUMENT_TYPE
static constexpr size_t PARAMETER_CONSTRUCTOR_ARGUMENT_TYPE
Definition: ParameterDescriptor.hpp:47
dw
Definition: Exception.hpp:47