Public Types | Public Member Functions | Private Types | Private Member Functions | Private Attributes | List of all members
fhicl::Tuple< TYPES > Class Template Reference

#include "/cvmfs/nova.opensciencegrid.org/externals/fhiclcpp/v4_06_10/source/fhiclcpp/type_traits.h"

Inheritance diagram for fhicl::Tuple< TYPES >:
fhicl::detail::SequenceBase fhicl::detail::RegisterIfTableMember fhicl::detail::ParameterBase

Public Types

using default_type = tuple_detail::ValueHolder< typename tt::fhicl_type< TYPES >::default_type... >
 
using value_type = std::tuple< tt::return_type< TYPES >... >
 
using ftype = std::tuple< std::shared_ptr< tt::fhicl_type< TYPES >>... >
 

Public Member Functions

 Tuple (Name &&name)
 
 Tuple (Name &&name, Comment &&comment)
 
 Tuple (Name &&name, Comment &&comment, std::function< bool()> maybeUse)
 
 Tuple (Name &&name, default_type const &defaults)
 
 Tuple (Name &&name, Comment &&comment, default_type const &defaults)
 
 Tuple (Name &&name, Comment &&comment, std::function< bool()> maybeUse, default_type const &defaults)
 
auto operator() () const
 
template<std::size_t I>
auto get () const
 
bool empty () const
 
std::size_t size () const
 
void prepare_elements_for_validation (std::size_t const n)
 
void walk_elements (ParameterWalker< tt::const_flavor::require_non_const > &pw)
 
void walk_elements (ParameterWalker< tt::const_flavor::require_const > &pw) const
 
std::string key () const
 
std::string name () const
 
std::string comment () const
 
bool has_default () const
 
bool is_optional () const
 
bool is_conditional () const
 
par_type parameter_type () const
 
bool should_use () const
 
void set_value (fhicl::ParameterSet const &ps, bool trimParents)
 
void set_par_style (par_style const vt)
 
void set_key (std::string const &key)
 

Private Types

using TUPLE = std::tuple< tt::fhicl_type< TYPES >... >
 
using UTUPLE = std::tuple< TYPES... >
 
using PW_non_const = detail::ParameterWalker< tt::const_flavor::require_non_const >
 
using PW_const = detail::ParameterWalker< tt::const_flavor::require_const >
 

Private Member Functions

std::size_t get_size () const override
 
void do_set_value (fhicl::ParameterSet const &, bool) override
 
void visit_element (PW_non_const &)
 
template<typename E , typename... T>
void visit_element (PW_non_const &pw, E &elem, T &...others)
 
template<std::size_t... I>
void iterate_over_tuple (PW_non_const &pw, std::index_sequence< I... >)
 
void do_prepare_elements_for_validation (std::size_t const n) override
 
void do_walk_elements (PW_non_const &pw) override
 
void visit_element (PW_const &) const
 
template<typename E , typename... T>
void visit_element (PW_const &pw, E const &elem, T const &...others) const
 
template<std::size_t... I>
void iterate_over_tuple (PW_const &pw, std::index_sequence< I... >) const
 
void do_walk_elements (PW_const &pw) const override
 
void finalize_tuple_elements (std::size_t)
 
template<typename E , typename... T>
void finalize_tuple_elements (std::size_t i, E &elem, T &...others)
 
template<std::size_t... I>
void finalize_elements (std::index_sequence< I... >)
 
template<size_t I>
std::enable_if_t<(I >=std::tuple_size< TUPLE >::value)> fill_tuple_element (default_type const &)
 
template<size_t I>
std::enable_if_t<(I< std::tuple_size< TUPLE >::value)> fill_tuple_element (default_type const &defaults)
 
void fill_tuple_elements (default_type const &default_values)
 
template<size_t I, typename value_type >
std::enable_if_t<(I >=std::tuple_size< TUPLE >::value)> fill_return_element (value_type &) const
 
template<size_t I, typename value_type >
std::enable_if_t<(I< std::tuple_size< TUPLE >::value)> fill_return_element (value_type &result) const
 
void assemble_rtype (value_type &result) const
 
template<size_t I>
std::enable_if_t<(I >=std::tuple_size< TUPLE >::value)> prepare_element_for_validation ()
 
template<size_t I>
std::enable_if_t<(I< std::tuple_size< TUPLE >::value)> prepare_element_for_validation ()
 

Private Attributes

ftype value_
 

Detailed Description

template<typename... TYPES>
class fhicl::Tuple< TYPES >

Definition at line 38 of file type_traits.h.

Member Typedef Documentation

template<typename... TYPES>
using fhicl::Tuple< TYPES >::default_type = tuple_detail::ValueHolder< typename tt::fhicl_type<TYPES>::default_type...>

Definition at line 60 of file Tuple.h.

template<typename... TYPES>
using fhicl::Tuple< TYPES >::ftype = std::tuple<std::shared_ptr<tt::fhicl_type<TYPES>>...>

Definition at line 62 of file Tuple.h.

template<typename... TYPES>
using fhicl::Tuple< TYPES >::PW_const = detail::ParameterWalker<tt::const_flavor::require_const>
private

Definition at line 111 of file Tuple.h.

template<typename... TYPES>
using fhicl::Tuple< TYPES >::PW_non_const = detail::ParameterWalker<tt::const_flavor::require_non_const>
private

Definition at line 110 of file Tuple.h.

template<typename... TYPES>
using fhicl::Tuple< TYPES >::TUPLE = std::tuple<tt::fhicl_type<TYPES>...>
private

Definition at line 92 of file Tuple.h.

template<typename... TYPES>
using fhicl::Tuple< TYPES >::UTUPLE = std::tuple<TYPES...>
private

Definition at line 93 of file Tuple.h.

template<typename... TYPES>
using fhicl::Tuple< TYPES >::value_type = std::tuple<tt::return_type<TYPES>...>

Definition at line 61 of file Tuple.h.

Constructor & Destructor Documentation

template<typename... TYPES>
fhicl::Tuple< TYPES >::Tuple ( Name &&  name)
explicit

Definition at line 275 of file Tuple.h.

275  : Tuple{std::move(name), Comment("")}
276  {}
const XML_Char * name
Definition: expat.h:151
Tuple(Name &&name)
Definition: Tuple.h:275
template<typename... TYPES>
fhicl::Tuple< TYPES >::Tuple ( Name &&  name,
Comment &&  comment 
)
explicit

Definition at line 279 of file Tuple.h.

References fhicl::detail::AlwaysUse(), fhicl::detail::ParameterBase::comment(), fhicl::NameStackRegistry::end_of_ctor(), fhicl::Tuple< TYPES >::finalize_elements(), fhicl::detail::RegisterIfTableMember::RegisterIfTableMember(), fhicl::REQUIRED, and fhicl::TUPLE.

280  : SequenceBase{std::move(name),
281  std::move(comment),
285  , RegisterIfTableMember{this}
286  {
287  finalize_elements(std::index_sequence_for<TYPES...>{});
289  }
const XML_Char * name
Definition: expat.h:151
std::function< bool()> AlwaysUse()
SequenceBase(Name &&name, Comment &&comment, par_style const vt, par_type const type, std::function< bool()> maybeUse)
Definition: SequenceBase.h:20
void finalize_elements(std::index_sequence< I... >)
Definition: Tuple.h:200
std::string comment() const
Definition: ParameterBase.h:54
template<typename... TYPES>
fhicl::Tuple< TYPES >::Tuple ( Name &&  name,
Comment &&  comment,
std::function< bool()>  maybeUse 
)
explicit

Definition at line 292 of file Tuple.h.

References fhicl::detail::ParameterBase::comment(), fhicl::NameStackRegistry::end_of_ctor(), fhicl::Tuple< TYPES >::finalize_elements(), fhicl::detail::RegisterIfTableMember::RegisterIfTableMember(), fhicl::REQUIRED_CONDITIONAL, and fhicl::TUPLE.

295  : SequenceBase{std::move(name),
296  std::move(comment),
299  maybeUse}
300  , RegisterIfTableMember{this}
301  {
302  finalize_elements(std::index_sequence_for<TYPES...>{});
304  }
const XML_Char * name
Definition: expat.h:151
SequenceBase(Name &&name, Comment &&comment, par_style const vt, par_type const type, std::function< bool()> maybeUse)
Definition: SequenceBase.h:20
void finalize_elements(std::index_sequence< I... >)
Definition: Tuple.h:200
std::string comment() const
Definition: ParameterBase.h:54
template<typename... TYPES>
fhicl::Tuple< TYPES >::Tuple ( Name &&  name,
default_type const &  defaults 
)
explicit

Definition at line 309 of file Tuple.h.

310  : Tuple{std::move(name), Comment(""), defaults}
311  {}
const XML_Char * name
Definition: expat.h:151
Tuple(Name &&name)
Definition: Tuple.h:275
template<typename... TYPES>
fhicl::Tuple< TYPES >::Tuple ( Name &&  name,
Comment &&  comment,
default_type const &  defaults 
)
explicit

Definition at line 314 of file Tuple.h.

References fhicl::detail::AlwaysUse(), fhicl::detail::ParameterBase::comment(), fhicl::DEFAULT, fhicl::NameStackRegistry::end_of_ctor(), fhicl::Tuple< TYPES >::fill_tuple_elements(), fhicl::detail::RegisterIfTableMember::RegisterIfTableMember(), and fhicl::TUPLE.

317  : SequenceBase{std::move(name),
318  std::move(comment),
322  , RegisterIfTableMember{this}
323  {
324  fill_tuple_elements(defaults);
326  }
const XML_Char * name
Definition: expat.h:151
void fill_tuple_elements(default_type const &default_values)
Definition: Tuple.h:229
std::function< bool()> AlwaysUse()
SequenceBase(Name &&name, Comment &&comment, par_style const vt, par_type const type, std::function< bool()> maybeUse)
Definition: SequenceBase.h:20
std::string comment() const
Definition: ParameterBase.h:54
template<typename... TYPES>
fhicl::Tuple< TYPES >::Tuple ( Name &&  name,
Comment &&  comment,
std::function< bool()>  maybeUse,
default_type const &  defaults 
)
explicit

Definition at line 329 of file Tuple.h.

References fhicl::detail::ParameterBase::comment(), fhicl::DEFAULT_CONDITIONAL, fhicl::NameStackRegistry::end_of_ctor(), fhicl::Tuple< TYPES >::fill_tuple_elements(), fhicl::detail::RegisterIfTableMember::RegisterIfTableMember(), and fhicl::TUPLE.

333  : SequenceBase{std::move(name),
334  std::move(comment),
337  maybeUse}
338  , RegisterIfTableMember{this}
339  {
340  fill_tuple_elements(defaults);
342  }
const XML_Char * name
Definition: expat.h:151
void fill_tuple_elements(default_type const &default_values)
Definition: Tuple.h:229
SequenceBase(Name &&name, Comment &&comment, par_style const vt, par_type const type, std::function< bool()> maybeUse)
Definition: SequenceBase.h:20
std::string comment() const
Definition: ParameterBase.h:54

Member Function Documentation

template<typename... TYPES>
void fhicl::Tuple< TYPES >::assemble_rtype ( value_type result) const
inlineprivate

Definition at line 250 of file Tuple.h.

References fillBadChanDBTables::result.

Referenced by fhicl::Tuple< TYPES >::operator()().

251  {
252  fill_return_element<0>(result);
253  }
std::string fhicl::detail::ParameterBase::comment ( ) const
inlineinherited
template<typename... TYPES>
void fhicl::Tuple< TYPES >::do_prepare_elements_for_validation ( std::size_t const  n)
inlineoverrideprivatevirtual

Implements fhicl::detail::SequenceBase.

Definition at line 138 of file Tuple.h.

References fhicl::detail::check_nargs_for_bounded_sequences(), and findDuplicateFiles::key.

139  {
141  }
void check_nargs_for_bounded_sequences(std::string const &key, std::size_t expected, std::size_t provided)
std::size_t get_size() const override
Definition: Tuple.h:98
std::string key() const
Definition: ParameterBase.h:44
template<typename... TYPES>
void fhicl::Tuple< TYPES >::do_set_value ( fhicl::ParameterSet const &  ,
bool   
)
inlineoverrideprivatevirtual

Implements fhicl::detail::ParameterBase.

Definition at line 104 of file Tuple.h.

105  {}
template<typename... TYPES>
void fhicl::Tuple< TYPES >::do_walk_elements ( PW_non_const pw)
inlineoverrideprivatevirtual

Implements fhicl::detail::SequenceBase.

Definition at line 144 of file Tuple.h.

145  {
146  iterate_over_tuple(pw, std::index_sequence_for<TYPES...>{});
147  }
void iterate_over_tuple(PW_non_const &pw, std::index_sequence< I... >)
Definition: Tuple.h:132
template<typename... TYPES>
void fhicl::Tuple< TYPES >::do_walk_elements ( PW_const pw) const
inlineoverrideprivatevirtual

Implements fhicl::detail::SequenceBase.

Definition at line 174 of file Tuple.h.

175  {
176  iterate_over_tuple(pw, std::index_sequence_for<TYPES...>{});
177  }
void iterate_over_tuple(PW_non_const &pw, std::index_sequence< I... >)
Definition: Tuple.h:132
bool fhicl::detail::SequenceBase::empty ( ) const
inlineinherited

Definition at line 29 of file SequenceBase.h.

References fhicl::detail::SequenceBase::size().

30  {
31  return size() == 0;
32  }
std::size_t size() const
Definition: SequenceBase.h:34
template<typename... TYPES>
template<size_t I, typename value_type >
std::enable_if_t<(I >= std::tuple_size<TUPLE>::value)> fhicl::Tuple< TYPES >::fill_return_element ( value_type ) const
inlineprivate

Definition at line 238 of file Tuple.h.

239  {}
template<typename... TYPES>
template<size_t I, typename value_type >
std::enable_if_t<(I < std::tuple_size<TUPLE>::value)> fhicl::Tuple< TYPES >::fill_return_element ( value_type result) const
inlineprivate

Definition at line 243 of file Tuple.h.

References fillBadChanDBTables::result.

244  {
245  std::get<I>(result) = (*std::get<I>(value_))();
246  fill_return_element<I + 1>(result);
247  }
ftype value_
Definition: Tuple.h:95
template<typename... TYPES>
template<size_t I>
std::enable_if_t<(I >= std::tuple_size<TUPLE>::value)> fhicl::Tuple< TYPES >::fill_tuple_element ( default_type const &  )
inlineprivate

Definition at line 209 of file Tuple.h.

210  {}
template<typename... TYPES>
template<size_t I>
std::enable_if_t<(I < std::tuple_size<TUPLE>::value)> fhicl::Tuple< TYPES >::fill_tuple_element ( default_type const &  defaults)
inlineprivate

Definition at line 214 of file Tuple.h.

References NO_DEFAULTS_FOR_TABLE, NO_DELEGATED_PARAMETERS, NO_STD_CONTAINERS, fhicl::Name::sequence_element(), and value_.

215  {
216  using elem_utype = std::tuple_element_t<I, UTUPLE>;
222  auto& elem = std::get<I>(value_);
223  elem = std::make_shared<tt::fhicl_type<elem_utype>>(
224  Name::sequence_element(I), defaults.template get<I>());
225  fill_tuple_element<I + 1>(defaults);
226  }
#define NO_DELEGATED_PARAMETERS
ftype value_
Definition: Tuple.h:95
#define NO_STD_CONTAINERS
static Name sequence_element(std::size_t const i)
Definition: Name.h:17
#define NO_DEFAULTS_FOR_TABLE
template<typename... TYPES>
void fhicl::Tuple< TYPES >::fill_tuple_elements ( default_type const &  default_values)
inlineprivate

Definition at line 229 of file Tuple.h.

Referenced by fhicl::Tuple< TYPES >::Tuple().

230  {
231  fill_tuple_element<0>(default_values);
232  }
template<typename... TYPES>
template<std::size_t... I>
void fhicl::Tuple< TYPES >::finalize_elements ( std::index_sequence< I... >  )
inlineprivate

Definition at line 200 of file Tuple.h.

Referenced by fhicl::Tuple< TYPES >::Tuple().

201  {
202  finalize_tuple_elements(0, std::get<I>(value_)...);
203  }
ftype value_
Definition: Tuple.h:95
void finalize_tuple_elements(std::size_t)
Definition: Tuple.h:181
template<typename... TYPES>
void fhicl::Tuple< TYPES >::finalize_tuple_elements ( std::size_t  )
inlineprivate

Definition at line 181 of file Tuple.h.

References E, and T.

181 {}
template<typename... TYPES>
template<typename E , typename... T>
void fhicl::Tuple< TYPES >::finalize_tuple_elements ( std::size_t  i,
E elem,
T &...  others 
)
inlineprivate

Definition at line 185 of file Tuple.h.

References NO_DELEGATED_PARAMETERS, NO_NESTED_TABLE_FRAGMENTS, NO_OPTIONAL_TYPES, and fhicl::Name::sequence_element().

186  {
187  using elem_ftype = typename E::element_type;
194  elem = std::make_shared<elem_ftype>(Name::sequence_element(i));
195  finalize_tuple_elements(++i, others...);
196  }
#define NO_DELEGATED_PARAMETERS
#define NO_OPTIONAL_TYPES
#define NO_NESTED_TABLE_FRAGMENTS
static Name sequence_element(std::size_t const i)
Definition: Name.h:17
void finalize_tuple_elements(std::size_t)
Definition: Tuple.h:181
template<typename... TYPES>
template<std::size_t I>
auto fhicl::Tuple< TYPES >::get ( ) const
inline

Definition at line 84 of file Tuple.h.

References value_.

85  {
86  return (*std::get<I>(value_))();
87  }
ftype value_
Definition: Tuple.h:95
template<typename... TYPES>
std::size_t fhicl::Tuple< TYPES >::get_size ( ) const
inlineoverrideprivatevirtual

Implements fhicl::detail::SequenceBase.

Definition at line 98 of file Tuple.h.

99  {
100  return std::tuple_size<ftype>();
101  }
bool fhicl::detail::ParameterBase::has_default ( ) const
inlineinherited
bool fhicl::detail::ParameterBase::is_conditional ( ) const
inlineinherited
bool fhicl::detail::ParameterBase::is_optional ( ) const
inlineinherited
template<typename... TYPES>
template<std::size_t... I>
void fhicl::Tuple< TYPES >::iterate_over_tuple ( PW_non_const pw,
std::index_sequence< I... >   
)
inlineprivate

Definition at line 132 of file Tuple.h.

133  {
134  visit_element(pw, std::get<I>(value_)...);
135  }
ftype value_
Definition: Tuple.h:95
void visit_element(PW_non_const &)
Definition: Tuple.h:114
template<typename... TYPES>
template<std::size_t... I>
void fhicl::Tuple< TYPES >::iterate_over_tuple ( PW_const pw,
std::index_sequence< I... >   
) const
inlineprivate

Definition at line 168 of file Tuple.h.

169  {
170  visit_element(pw, std::get<I>(value_)...);
171  }
ftype value_
Definition: Tuple.h:95
void visit_element(PW_non_const &)
Definition: Tuple.h:114
std::string fhicl::detail::ParameterBase::key ( ) const
inlineinherited
std::string fhicl::detail::ParameterBase::name ( ) const
inlineinherited
template<typename... TYPES>
auto fhicl::Tuple< TYPES >::operator() ( void  ) const

Definition at line 346 of file Tuple.h.

References fhicl::Tuple< TYPES >::assemble_rtype(), and fillBadChanDBTables::result.

347  {
349  assemble_rtype(result);
350  return result;
351  }
void assemble_rtype(value_type &result) const
Definition: Tuple.h:250
std::tuple< tt::return_type< TYPES >... > value_type
Definition: Tuple.h:61
par_type fhicl::detail::ParameterBase::parameter_type ( ) const
inlineinherited
template<typename... TYPES>
template<size_t I>
std::enable_if_t<(I >= std::tuple_size<TUPLE>::value)> fhicl::Tuple< TYPES >::prepare_element_for_validation ( )
inlineprivate

Definition at line 259 of file Tuple.h.

260  {}
template<typename... TYPES>
template<size_t I>
std::enable_if_t<(I < std::tuple_size<TUPLE>::value)> fhicl::Tuple< TYPES >::prepare_element_for_validation ( )
inlineprivate

Definition at line 264 of file Tuple.h.

References fhicl::REQUIRED, and value_.

265  {
267  prepare_element_for_validation<I + 1>();
268  }
ftype value_
Definition: Tuple.h:95
void set_par_style(par_style const vt)
void fhicl::detail::SequenceBase::prepare_elements_for_validation ( std::size_t const  n)
inlineinherited

Definition at line 40 of file SequenceBase.h.

References fhicl::detail::SequenceBase::do_prepare_elements_for_validation().

41  {
43  }
virtual void do_prepare_elements_for_validation(std::size_t)=0
void fhicl::detail::ParameterBase::set_key ( std::string const &  key)
inlineinherited
void fhicl::detail::ParameterBase::set_par_style ( par_style const  vt)
inlineinherited
void fhicl::detail::ParameterBase::set_value ( fhicl::ParameterSet const &  ps,
bool  trimParents 
)
inlineinherited

Definition at line 96 of file ParameterBase.h.

References fhicl::detail::ParameterBase::do_set_value().

97  {
98  do_set_value(ps, trimParents);
99  }
virtual void do_set_value(fhicl::ParameterSet const &, bool trimParents)=0
bool fhicl::detail::ParameterBase::should_use ( ) const
inlineinherited

Definition at line 79 of file ParameterBase.h.

References fhicl::detail::ParameterBase::maybeUse_.

80  {
81  return maybeUse_();
82  }
std::function< bool()> maybeUse_
std::size_t fhicl::detail::SequenceBase::size ( void  ) const
inlineinherited

Definition at line 34 of file SequenceBase.h.

References fhicl::detail::SequenceBase::get_size().

Referenced by fhicl::detail::SequenceBase::empty().

35  {
36  return get_size();
37  }
virtual std::size_t get_size() const =0
template<typename... TYPES>
void fhicl::Tuple< TYPES >::visit_element ( PW_non_const )
inlineprivate

Definition at line 114 of file Tuple.h.

References E, and T.

115  {}
template<typename... TYPES>
template<typename E , typename... T>
void fhicl::Tuple< TYPES >::visit_element ( PW_non_const pw,
E elem,
T &...  others 
)
inlineprivate

Definition at line 119 of file Tuple.h.

References NO_DELEGATED_PARAMETERS, NO_NESTED_TABLE_FRAGMENTS, NO_OPTIONAL_TYPES, and fhicl::detail::ParameterWalker< C >::walk_over().

120  {
121  static_assert(!tt::is_table_fragment<E>::value,
126  pw.walk_over(*elem);
127  visit_element(pw, others...);
128  }
#define NO_DELEGATED_PARAMETERS
#define NO_OPTIONAL_TYPES
#define NO_NESTED_TABLE_FRAGMENTS
void visit_element(PW_non_const &)
Definition: Tuple.h:114
template<typename... TYPES>
void fhicl::Tuple< TYPES >::visit_element ( PW_const ) const
inlineprivate

Definition at line 150 of file Tuple.h.

References E, and T.

151  {}
template<typename... TYPES>
template<typename E , typename... T>
void fhicl::Tuple< TYPES >::visit_element ( PW_const pw,
E const &  elem,
T const &...  others 
) const
inlineprivate

Definition at line 155 of file Tuple.h.

References NO_DELEGATED_PARAMETERS, NO_NESTED_TABLE_FRAGMENTS, NO_OPTIONAL_TYPES, and fhicl::detail::ParameterWalker< C >::walk_over().

156  {
157  static_assert(!tt::is_table_fragment<E>::value,
162  pw.walk_over(*elem);
163  visit_element(pw, others...);
164  }
#define NO_DELEGATED_PARAMETERS
#define NO_OPTIONAL_TYPES
#define NO_NESTED_TABLE_FRAGMENTS
void visit_element(PW_non_const &)
Definition: Tuple.h:114
void fhicl::detail::SequenceBase::walk_elements ( ParameterWalker< tt::const_flavor::require_non_const > &  pw)
inlineinherited

Definition at line 45 of file SequenceBase.h.

References fhicl::detail::SequenceBase::do_walk_elements().

46  {
47  do_walk_elements(pw);
48  }
virtual void do_walk_elements(ParameterWalker< tt::const_flavor::require_non_const > &)=0
void fhicl::detail::SequenceBase::walk_elements ( ParameterWalker< tt::const_flavor::require_const > &  pw) const
inlineinherited

Definition at line 50 of file SequenceBase.h.

References fhicl::detail::SequenceBase::do_prepare_elements_for_validation(), fhicl::detail::SequenceBase::do_walk_elements(), and fhicl::detail::SequenceBase::get_size().

51  {
52  do_walk_elements(pw);
53  }
virtual void do_walk_elements(ParameterWalker< tt::const_flavor::require_non_const > &)=0

Member Data Documentation

template<typename... TYPES>
ftype fhicl::Tuple< TYPES >::value_
private

Definition at line 95 of file Tuple.h.


The documentation for this class was generated from the following files: