Project

General

Profile

Fhiclcpp types in detail » History » Version 41

Kyle Knoepfel, 12/16/2015 08:25 AM

1 1 Kyle Knoepfel
h1. @fhiclcpp@ types in detail
2 1 Kyle Knoepfel
3 34 Kyle Knoepfel
{{toc}}
4 1 Kyle Knoepfel
5 9 Kyle Knoepfel
----
6 9 Kyle Knoepfel
7 17 Kyle Knoepfel
h1(#ctors). Parameter constructors
8 1 Kyle Knoepfel
9 18 Kyle Knoepfel
h2(#ctors_rules). %{color:blue}General rules%
10 1 Kyle Knoepfel
11 1 Kyle Knoepfel
For each of the @fhiclcpp@ types, the following rules apply:
12 12 Kyle Knoepfel
* The @Name@ argument is required.
13 32 Kyle Knoepfel
* Neither the @Table<T>@ parameter nor any of the @Optional*@ parameters support a default value.
14 1 Kyle Knoepfel
15 39 Kyle Knoepfel
h3(#opt_comment). Note about optional parameters
16 39 Kyle Knoepfel
17 39 Kyle Knoepfel
In addition to @Optional*@ parameters not supporting default values, they also cannot be used as template arguments to *any* @fhiclcpp@ types:
18 39 Kyle Knoepfel
19 39 Kyle Knoepfel
<pre><code class="cpp">
20 39 Kyle Knoepfel
Sequence< OptionalSequence<int> >     e1 { ... };  // error
21 39 Kyle Knoepfel
Sequence< OptionalSequence<int,2u> >  e2 { ... };  // error
22 39 Kyle Knoepfel
Sequence< OptionalTuple<int,double> > e3 { ... };  // error
23 40 Kyle Knoepfel
OptionalSequence< Sequence<int> >     ok { ... };  // ok
24 39 Kyle Knoepfel
</code></pre>
25 39 Kyle Knoepfel
26 18 Kyle Knoepfel
h2(#atom). %{color:blue}@Atom<T>@%
27 7 Kyle Knoepfel
28 1 Kyle Knoepfel
<pre><code class="cpp">
29 1 Kyle Knoepfel
Atom<int> var { Name("var") };
30 1 Kyle Knoepfel
Atom<int> var { Name("var"), 9 };
31 7 Kyle Knoepfel
Atom<int> var { Name("var"), Comment("A parameter description") };
32 1 Kyle Knoepfel
Atom<int> var { Name("var"), Comment("A parameter description"), 9 };
33 1 Kyle Knoepfel
</code></pre>
34 33 Kyle Knoepfel
35 39 Kyle Knoepfel
36 33 Kyle Knoepfel
h2(#opt_atom). %{color:blue}@OptionalAtom<T>@%
37 33 Kyle Knoepfel
38 33 Kyle Knoepfel
<pre><code class="cpp">
39 33 Kyle Knoepfel
OptionalAtom<int> var { Name("var") };
40 33 Kyle Knoepfel
OptionalAtom<int> var { Name("var"), Comment("A parameter description") };
41 33 Kyle Knoepfel
</code></pre>
42 33 Kyle Knoepfel
43 33 Kyle Knoepfel
h2(#opt_vector). %{color:blue}@OptionalSequence<T>@%
44 1 Kyle Knoepfel
45 39 Kyle Knoepfel
This class template is used for unbounded sequences.
46 33 Kyle Knoepfel
47 33 Kyle Knoepfel
<pre><code class="cpp">
48 33 Kyle Knoepfel
OptionalSequence<int> seq { Name("seq") };
49 33 Kyle Knoepfel
OptionalSequence<int> seq { Name("seq"), Comment("A sequence") };
50 33 Kyle Knoepfel
</code></pre>
51 33 Kyle Knoepfel
52 33 Kyle Knoepfel
h2(#opt_array). %{color:blue}@OptionalSequence<T,std::size_t>@%
53 33 Kyle Knoepfel
54 33 Kyle Knoepfel
This class template is used for sequences of a specific length, known at compile time.
55 33 Kyle Knoepfel
56 33 Kyle Knoepfel
<pre><code class="cpp">
57 33 Kyle Knoepfel
OptionalSequence<int,3u> seq { Name("seq") };
58 33 Kyle Knoepfel
OptionalSequence<int,3u> seq { Name("seq"), Comment("A sequence") };
59 33 Kyle Knoepfel
</code></pre>
60 33 Kyle Knoepfel
61 33 Kyle Knoepfel
h2(#opt_table). %{color:blue}@OptionalTable<T>@%
62 33 Kyle Knoepfel
63 33 Kyle Knoepfel
<pre><code class="cpp">
64 33 Kyle Knoepfel
OptionalTable<T> config { Name("config") };
65 33 Kyle Knoepfel
OptionalTable<T> config { Name("config"), Comment("This describes the table") };
66 33 Kyle Knoepfel
</code></pre>
67 33 Kyle Knoepfel
68 33 Kyle Knoepfel
h2(#opt_tuple). %{color:blue}@OptionalTuple<T...>@%
69 33 Kyle Knoepfel
70 33 Kyle Knoepfel
<pre><code class="cpp">
71 33 Kyle Knoepfel
OptionalTuple<string,bool> tuple { Name("tuple") };
72 33 Kyle Knoepfel
OptionalTuple<string,bool> tuple { Name("tuple"), Comment("A tuple") };
73 33 Kyle Knoepfel
</code></pre>
74 33 Kyle Knoepfel
75 18 Kyle Knoepfel
h2(#vector). %{color:blue}@Sequence<T>@%
76 1 Kyle Knoepfel
77 18 Kyle Knoepfel
This class template is used for unbounded sequences.  See the two caveats below.
78 18 Kyle Knoepfel
79 1 Kyle Knoepfel
<pre><code class="cpp">
80 7 Kyle Knoepfel
Sequence<int> seq { Name("seq") };
81 1 Kyle Knoepfel
Sequence<int> seq { Name("seq"), Comment("A sequence") };
82 1 Kyle Knoepfel
Sequence<int> seq { Name("seq"), Sequence<int>{ 4, 5, 6, 7 } };
83 1 Kyle Knoepfel
Sequence<int> seq { Name("seq"), { 4, 5, 6, 7 } };
84 1 Kyle Knoepfel
Sequence<int> seq { Name("seq"), Comment("A sequence"), Sequence<int>{ 4, 5, 6, 7 } };
85 1 Kyle Knoepfel
Sequence<int> seq { Name("seq"), Comment("A sequence"), { 4, 5, 6, 7 } };
86 1 Kyle Knoepfel
</code></pre>
87 1 Kyle Knoepfel
88 1 Kyle Knoepfel
h3(#make_empty). @Sequence<T>::make_empty()@
89 1 Kyle Knoepfel
90 8 Kyle Knoepfel
Due to the implementation details of the unbounded sequence, the following:
91 1 Kyle Knoepfel
92 8 Kyle Knoepfel
<pre><code class="cpp">
93 1 Kyle Knoepfel
Sequence<int> seq { Name("seq"), Sequence<int>{} }; // Don't do this.
94 1 Kyle Knoepfel
</code></pre>
95 1 Kyle Knoepfel
96 18 Kyle Knoepfel
_does not_ represent an empty sequence.  If you would like an empty sequence as a default value, use the following:
97 1 Kyle Knoepfel
98 1 Kyle Knoepfel
<pre><code class="cpp">
99 1 Kyle Knoepfel
Sequence<int> seq { Name("seq"), Sequence<int>::make_empty() };
100 1 Kyle Knoepfel
</code></pre>
101 1 Kyle Knoepfel
102 18 Kyle Knoepfel
h3(#narrowing). Precaution regarding narrowing conversions and @std::initializer_list@ objects
103 1 Kyle Knoepfel
104 19 Kyle Knoepfel
The following configuration will trigger a compilation warning:
105 19 Kyle Knoepfel
106 19 Kyle Knoepfel
<pre><code class="cpp">
107 19 Kyle Knoepfel
Sequence<int> seq1 { Name("seq1"), Sequence<int>{ 1, 2.4e-4 } };
108 19 Kyle Knoepfel
Sequence<int> seq2 { Name("seq2"), { 1, 2.4e-4 } };
109 19 Kyle Knoepfel
</code></pre>
110 19 Kyle Knoepfel
111 19 Kyle Knoepfel
that looks similar to this:
112 18 Kyle Knoepfel
113 18 Kyle Knoepfel
<pre>
114 18 Kyle Knoepfel
warning: narrowing conversion of ‘2.4000000000000001e-4’ from ‘double’ to ‘int’ inside { } [-Wnarrowing]
115 18 Kyle Knoepfel
</pre>
116 1 Kyle Knoepfel
117 1 Kyle Knoepfel
For build systems that convert compile-time warnings to errors, this will result in a build failure.  The warning results from the nature of an @std::initializer_list@ object, signified by @'{1, 2.4e-4}'@, which is used to initialize the sequence objects.  For @std::initializer_list@ objects, narrowing conversions are not allowed--that is, converting a @double@ to an @int@ is an example of narrowing that results in loss of information.  This is the most likely example of where you may find a narrowing conversion.
118 1 Kyle Knoepfel
119 1 Kyle Knoepfel
h2(#array). %{color:blue}@Sequence<T,std::size_t>@%
120 1 Kyle Knoepfel
121 1 Kyle Knoepfel
This class template is used for sequences of a specific length, known at compile time.
122 1 Kyle Knoepfel
123 1 Kyle Knoepfel
<pre><code class="cpp">
124 1 Kyle Knoepfel
Sequence<int,3u> seq { Name("seq") };
125 18 Kyle Knoepfel
Sequence<int,3u> seq { Name("seq"), Comment("A sequence") };
126 17 Kyle Knoepfel
Sequence<int,3u> seq { Name("seq"), Sequence<int,3u>{ 4, 5, 6 } };
127 18 Kyle Knoepfel
Sequence<int,3u> seq { Name("seq"), { 4, 5, 6 } };
128 18 Kyle Knoepfel
Sequence<int,3u> seq { Name("seq"), Comment("A sequence"), Sequence<int,3u>{ 4, 5, 6 } };
129 1 Kyle Knoepfel
Sequence<int,3u> seq { Name("seq"), Comment("A sequence"), { 4, 5, 6 } };
130 1 Kyle Knoepfel
</code></pre>
131 1 Kyle Knoepfel
132 1 Kyle Knoepfel
The warning regarding narrowing conversions [[Fhiclcpp_types_in_detail#narrowing|above]] applies for bounded sequences as well.
133 1 Kyle Knoepfel
134 33 Kyle Knoepfel
h2(#table). %{color:blue}@Table<T>@%
135 33 Kyle Knoepfel
136 33 Kyle Knoepfel
<pre><code class="cpp">
137 33 Kyle Knoepfel
Table<T> config { Name("config") };
138 33 Kyle Knoepfel
Table<T> config { Name("config"), Comment("This describes the table") };
139 33 Kyle Knoepfel
</code></pre>
140 33 Kyle Knoepfel
141 1 Kyle Knoepfel
h2(#tuple). %{color:blue}@Tuple<T...>@%
142 1 Kyle Knoepfel
143 1 Kyle Knoepfel
<pre><code class="cpp">
144 1 Kyle Knoepfel
Tuple<string,bool> tuple { Name("tuple") };
145 18 Kyle Knoepfel
Tuple<string,bool> tuple { Name("tuple"), Comment("A tuple") };
146 1 Kyle Knoepfel
Tuple<string,bool> tuple { Name("tuple"), Tuple<string,bool>{"explicit?", true} };
147 1 Kyle Knoepfel
Tuple<string,bool> tuple { Name("tuple"), {"compact?", true } };
148 1 Kyle Knoepfel
Tuple<string,bool> tuple { Name("tuple"), Comment("A tuple"), Tuple<string,bool>{ "Particle physics is neat.", true } };
149 1 Kyle Knoepfel
Tuple<string,bool> tuple { Name("tuple"), Comment("A tuple"), { "This is false", false } };
150 1 Kyle Knoepfel
</code></pre>
151 1 Kyle Knoepfel
152 1 Kyle Knoepfel
----
153 1 Kyle Knoepfel
154 35 Kyle Knoepfel
h1(#return). Standard parameters - return types
155 35 Kyle Knoepfel
156 38 Kyle Knoepfel
_[ In what follows, @array@, @string@, @tuple@, and @vector@ should each be prefaced with the appropriate namespace resolution: '@std::@'. ]_
157 37 Kyle Knoepfel
158 1 Kyle Knoepfel
|{background:#fba}. *@fhiclcpp@ parameter*|{background:#fba}. *Function call*|{background:#fba}. *Return type*|
159 1 Kyle Knoepfel
|\3{background:#ddd}. _Simple @fhiclcpp@ parameters_|
160 37 Kyle Knoepfel
|@Atom<string> label@; |@label()@| @string const&@|
161 37 Kyle Knoepfel
|/2.@Sequence<int> counts@; | @counts()@ | @vector<int>@|
162 35 Kyle Knoepfel
|@counts(1)@ | @int@ |
163 37 Kyle Knoepfel
|/2.@Sequence<double, 3u> point@;| @point()@ | @array<double, 3u>@|
164 1 Kyle Knoepfel
|@point(0)@ | @double@ |
165 37 Kyle Knoepfel
|/3.@Tuple<string, double> assoc;@|@assoc()@| @tuple<string, double>@|
166 37 Kyle Knoepfel
|@assoc.get<0>()@|@string@|
167 35 Kyle Knoepfel
|@assoc.get<double>()@|@double@|
168 35 Kyle Knoepfel
|@Table<Config> config;@|@config()@|@Config const&@|
169 35 Kyle Knoepfel
|\3{background:#ddd}. _Nested @fhiclcpp@ parameters_|
170 37 Kyle Knoepfel
|/2.@Sequence< Sequence<int> > datasets;@ | @datasets()@ | @vector< vector<int> >@ |
171 37 Kyle Knoepfel
| @datasets(17)@ | @vector<int>@ |
172 37 Kyle Knoepfel
|/2.@Sequence< Sequence<int>, 2u > twoDatasets;@ | @twoDatasets()@ | @array< vector<int>, 2u >@ |
173 37 Kyle Knoepfel
|@twoDatasets(1)@ | @vector<int>@ |
174 37 Kyle Knoepfel
|/2.@Sequence< Sequence<int, 2u> > intPairs;@ | @intPairs()@ | @vector< array<int, 2u> >@ |
175 37 Kyle Knoepfel
|@intPairs(42)@ | @array<int, 2u>@|
176 37 Kyle Knoepfel
|/2.@Sequence< Tuple<string, int, bool> > triplets;@ | @triplets()@ | @vector< tuple<string, int, bool> >@ |
177 37 Kyle Knoepfel
|@triplets(3)@ | @tuple<string, int, bool>@ |
178 37 Kyle Knoepfel
|/2.@Sequence< Table<Config> > manyConfigTables;@ | @manyConfigTables()@ | @vector< Config >@ |
179 35 Kyle Knoepfel
|@manyConfigTables(6)@ | @Config const&@ |
180 37 Kyle Knoepfel
|/3.@Tuple< string, Table<Config> > configAssoc;@ | @configAssoc()@ | @tuple< string, Config >@ |
181 37 Kyle Knoepfel
|@configAssoc.get<0>()@ | @string@ |
182 35 Kyle Knoepfel
|@configAssoc.get<1>()@ | @Config@ |
183 37 Kyle Knoepfel
|/3.@Tuple< Tuple<string,bool>, Sequence<int> > awkward;@ | @awkward()@ | @tuple< tuple<string, bool>, vector<int> >@ |
184 37 Kyle Knoepfel
|@awkward.get<0>()@|@tuple<string,bool>@|
185 37 Kyle Knoepfel
|@awkward.get<1>()@|@vector<int>@|
186 1 Kyle Knoepfel
187 36 Kyle Knoepfel
h1(#opt_arg). @Optional@ parameters - argument types
188 1 Kyle Knoepfel
189 38 Kyle Knoepfel
The usage pattern for @Optional@ @fhiclcpp@ parameters is:
190 38 Kyle Knoepfel
191 38 Kyle Knoepfel
<pre><code class="cpp">
192 38 Kyle Knoepfel
OptionalAtom<string> message { Name("message") };
193 38 Kyle Knoepfel
194 38 Kyle Knoepfel
string filled_msg; // passed argument
195 38 Kyle Knoepfel
196 38 Kyle Knoepfel
if ( message(filled_msg) ) {
197 38 Kyle Knoepfel
   // use 'filled_msg'
198 38 Kyle Knoepfel
}
199 38 Kyle Knoepfel
</code></pre>
200 38 Kyle Knoepfel
201 38 Kyle Knoepfel
The following table gives the required passed-argument types for a given @Optional@ parameter.
202 38 Kyle Knoepfel
203 38 Kyle Knoepfel
_[ In what follows, @array@, @string@, @tuple@, and @vector@ should each be prefaced with the appropriate namespace resolution: '@std::@'. ]_
204 38 Kyle Knoepfel
205 1 Kyle Knoepfel
|{background:#fba}. *@fhiclcpp@ parameter*|{background:#fba}. *Passed argument*|{background:#fba}. *Function call*|
206 1 Kyle Knoepfel
|\3{background:#ddd}. _Simple @fhiclcpp@ parameters_|
207 38 Kyle Knoepfel
|@OptionalAtom<string> label@; |@string l;@| @bool exists = label(l);@|
208 38 Kyle Knoepfel
|@OptionalSequence<int> counts@; | @vector<int> v;@|@bool exists = counts(v);@ |
209 38 Kyle Knoepfel
|@OptionalSequence<double, 3u> point@;| @array<double, 3u> p;@| @bool exists = point(p);@ |
210 38 Kyle Knoepfel
|@OptionalTuple<string, double> assoc;@|@tuple<string, double> t;@| @bool exists = assoc(t);@|
211 36 Kyle Knoepfel
|@OptionalTable<Config> config;@|@Config c;@|@bool exists = config(c);@|
212 14 Kyle Knoepfel
|\3{background:#ddd}. _Nested @fhiclcpp@ parameters_|
213 38 Kyle Knoepfel
|@OptionalSequence< Sequence<int> > datasets;@ |  @vector< vector<int> > sets;@ |@bool exists = datasets(sets);@ |
214 38 Kyle Knoepfel
|@OptionalSequence< Sequence<int>, 2u > twoDatasets;@ |  @array< vector<int>, 2u >@ sets; |@bool exists = twoDatasets(sets);@ |
215 38 Kyle Knoepfel
|@OptionalSequence< Sequence<int, 2u> > intPairs;@ | @vector< array<int, 2u> >@ prs; |@bool exists = intPairs(prs);@ |
216 38 Kyle Knoepfel
|@OptionalSequence< Tuple<string, int, bool> > triplets;@ |  @vector< tuple<string, int, bool> > trps;@ |@bool exists = triplets(trps);@ |
217 38 Kyle Knoepfel
|@OptionalSequence< Table<Config> > manyConfigTables;@ | @vector< Config > tbls;@ |@bool exists = manyConfigTables(tbls);@ |
218 38 Kyle Knoepfel
|@OptionalTuple< string, Table<Config> > configAssoc;@ | @tuple< string, Config > assoc;@ |@bool exists = configAssoc(assoc);@ |
219 38 Kyle Knoepfel
|@OptionalTuple< Tuple<string,bool>, Sequence<int> > awkward;@ | @tuple< tuple<string, bool>, vector<int> > wow;@ |@bool exists = awkward(wow);@ |
220 38 Kyle Knoepfel
221 21 Kyle Knoepfel
222 21 Kyle Knoepfel
----
223 21 Kyle Knoepfel
224 21 Kyle Knoepfel
h1(#table_func). Additional functions for @Table<T>@
225 21 Kyle Knoepfel
226 21 Kyle Knoepfel
The @Table@ template offers a few extra functions that the user can call: 
227 21 Kyle Knoepfel
228 21 Kyle Knoepfel
<pre><code class="cpp">
229 21 Kyle Knoepfel
fhicl::ParameterSet const& get_PSet() const;
230 21 Kyle Knoepfel
231 21 Kyle Knoepfel
void print_allowed_configuration(std::ostream& os,
232 21 Kyle Knoepfel
                                 std::string const& tab = std::string(3,' ') ) const;
233 21 Kyle Knoepfel
234 21 Kyle Knoepfel
// Expert-level functions
235 21 Kyle Knoepfel
void validate_ParameterSet(fhicl::ParameterSet const& pset,
236 21 Kyle Knoepfel
                           std::set<std::string> const& keysToIgnore = {} );
237 21 Kyle Knoepfel
238 21 Kyle Knoepfel
</code></pre>
239 24 Kyle Knoepfel
240 1 Kyle Knoepfel
h3(#get_pset). @get_PSet@
241 28 Kyle Knoepfel
242 24 Kyle Knoepfel
A call to this function returns a @const@ reference to the @ParameterSet@ object that was used to fill the values of the individual @Table@ members.  This is helpful for users who need to interact with the @ParameterSet@ object itself.
243 21 Kyle Knoepfel
244 21 Kyle Knoepfel
h3(#print). @print_allowed_configuration@
245 1 Kyle Knoepfel
246 21 Kyle Knoepfel
For any @Table<Config>@ object, @print_allowed_configuration@ will fill a user-supplied @std::ostream@ object with the allowed configuration as defined by the @Config@ struct.  The optional second argument specifies the number of spaces per indentation.  The default is 3 spaces but is, of course, user-configurable.
247 24 Kyle Knoepfel
248 21 Kyle Knoepfel
----
249 25 Kyle Knoepfel
250 25 Kyle Knoepfel
%{color:red} _[ *N.B.* The following function should not normally be invoked by users. It is meant to be called only in contexts outside of @art@.  Please consult artists@fnal.gov for guidance.]_%
251 17 Kyle Knoepfel
252 14 Kyle Knoepfel
h3(#validate). @validate_ParameterSet@ (expert)
253 14 Kyle Knoepfel
254 14 Kyle Knoepfel
This function is intended for experts who need to validate the @pset@ object themselves.  The @keysToIgnore@ variable represents a set of keys for which the validation step will ignore.  The validation function will ignore any nested keys as well--i.e. if a user specifies an ignorable key as @table1@, the (e.g.) @table1.someAtom@ key would be ignored in addition to just the @table1@ name.  An indexed parameter (e.g.) @seq[1]@ is considered a nested parameter of its parent @seq@.  Providing or not providing the ignorable key in a configuration will lead to no error upon validation of the @ParameterSet@.
255 14 Kyle Knoepfel
256 30 Kyle Knoepfel
Should the validation step fail, an exception is thrown of type @fhicl::detail::validationException@.  This behavior is not currently configurable.
257 14 Kyle Knoepfel
258 14 Kyle Knoepfel
----
259 30 Kyle Knoepfel
260 14 Kyle Knoepfel
h1(#common_acc). Common parameter accessors
261 14 Kyle Knoepfel
262 14 Kyle Knoepfel
Each of the @fhiclcpp@ types has the following accessors:
263 14 Kyle Knoepfel
<pre><code class="cpp">
264 14 Kyle Knoepfel
std::string key()            const;
265 14 Kyle Knoepfel
std::string name()           const;
266 14 Kyle Knoepfel
std::string comment()        const;
267 14 Kyle Knoepfel
bool        has_default()    const;
268 14 Kyle Knoepfel
bool        is_optional()    const;
269 14 Kyle Knoepfel
par_type    parameter_type() const;
270 14 Kyle Knoepfel
</code></pre>
271 14 Kyle Knoepfel
272 17 Kyle Knoepfel
To call these functions, the difference in syntax is crucial:
273 14 Kyle Knoepfel
274 14 Kyle Knoepfel
<pre><code class="cpp">
275 14 Kyle Knoepfel
Atom<int> val { Name("val") };
276 14 Kyle Knoepfel
277 14 Kyle Knoepfel
auto key1 = val.key();   //   correct
278 14 Kyle Knoepfel
auto key2 = val().key(); // ! compile-time ERROR - 'val()' is an int, which has no accessor called 'key()' 
279 14 Kyle Knoepfel
</code></pre>
280 31 Kyle Knoepfel
281 1 Kyle Knoepfel
h2. @key()@
282 30 Kyle Knoepfel
283 14 Kyle Knoepfel
A call to @key()@ returns the _full_ key, including all enclosing tables.  For example, consider a module that is designed to allow the following configuration:
284 30 Kyle Knoepfel
<pre><code class="ruby">
285 1 Kyle Knoepfel
pset: {
286 30 Kyle Knoepfel
  list: [ { particle: electron },
287 30 Kyle Knoepfel
          { particle: muon } ]
288 17 Kyle Knoepfel
}
289 14 Kyle Knoepfel
</code></pre>For a suitably declared set of @fhiclcpp@ parameters, the returned key corresponding to "muon" would be @pset.list[1].particle@.
290 14 Kyle Knoepfel
291 14 Kyle Knoepfel
h2. @name()@
292 17 Kyle Knoepfel
293 14 Kyle Knoepfel
The name is the most-nested name in the key.  For the above "muon" parameter, a key of @pset.list[1].particle@ has a corresponding name of @particle@.  If the parameter in question were @pset.list[1]@, the name would be[1] @list[1]@.
294 1 Kyle Knoepfel
295 1 Kyle Knoepfel
fn1. Technically, this is inaccurate -- sequence elements do not have names.  However, for the sake of parameter identification, a sequence element has a name whose value is the sequence name with the appropriate sequence element index/indices appended.
296 30 Kyle Knoepfel
297 30 Kyle Knoepfel
h2. @comment()@
298 30 Kyle Knoepfel
299 30 Kyle Knoepfel
Returns the comment supplied as the string literal in (e.g.) @Comment("Here is the comment")@.  If no @Comment@ argument is provided in the @fhiclcpp@ parameter constructor, a call to this function returns an empty string.
300 1 Kyle Knoepfel
301 1 Kyle Knoepfel
h2. @has_default()@
302 1 Kyle Knoepfel
303 1 Kyle Knoepfel
Returns @true@ or @false@ depending on whether the user supplied a default value for the parameter.
304 14 Kyle Knoepfel
305 14 Kyle Knoepfel
h2. @is_optional()@
306 30 Kyle Knoepfel
307 30 Kyle Knoepfel
Returns @true@ or @false@ depending on whether the parameter is of an @Optional*@ @fhiclcpp@ type.
308 30 Kyle Knoepfel
309 30 Kyle Knoepfel
h2. @parameter_type()@
310 30 Kyle Knoepfel
311 14 Kyle Knoepfel
Returns an enumeration value based on the parameter type:
312 14 Kyle Knoepfel
313 14 Kyle Knoepfel
<pre><code class="cpp">
314 1 Kyle Knoepfel
enum class par_type {
315 1 Kyle Knoepfel
  ATOM,        // (Optional)Atom<T>
316 1 Kyle Knoepfel
  TABLE,       // (Optional)Table<T>
317 1 Kyle Knoepfel
  SEQ_VECTOR,  // (Optional)Sequence<T>
318 1 Kyle Knoepfel
  SEQ_ARRAY,   // (Optional)Sequence<T,std::size_t>
319 1 Kyle Knoepfel
  TUPLE,       // (Optional)Tuple<T...>
320 1 Kyle Knoepfel
  NTYPES       // Signifies invalid parameter 
321 1 Kyle Knoepfel
};
322 1 Kyle Knoepfel
</code></pre>