#include <type_traits.h>

Inheritance diagram for fhicl::Table< T, KeysToIgnore >:

Classes
struct	Impl

Public Types
using	default_type = T

using	value_type = T

Public Member Functions
template<typename... TCARGS>
	Table (Name &&name, TCARGS &&...tcargs)

template<typename... TCARGS>
	Table (Name &&name, Comment &&comment, TCARGS &&...tcargs)

template<typename... TCARGS>
	Table (Name &&name, Comment &&comment, MaybeUseFunction maybeUse, TCARGS &&...tcargs)

template<typename K = KeysToIgnore, typename = std::enable_if_t<tt::is_callable<K>::value>>
	Table (ParameterSet const &pset)

template<typename K = KeysToIgnore, typename = std::enable_if_t<!tt::is_callable<K>::value>>
	Table (ParameterSet const &pset, std::set< std::string > const &keysToIgnore={})

auto const &	operator() () const

ParameterSet const &	get_PSet () const

void	validate (ParameterSet const &pset, std::set< std::string > const &keysToIgnore={})

void	print_allowed_configuration (std::ostream &os, std::string const &tab=std::string(3, ' ')) const

Public Member Functions inherited from fhicl::detail::TableBase
	TableBase (Name const &name, Comment const &comment, par_style const vt, std::function< bool()> maybeUse)

std::vector< cet::exempt_ptr< ParameterBase > > const &	members () const

Public Member Functions inherited from fhicl::detail::ParameterBase
std::string const &	key () const

std::string const &	name () const

std::string const &	comment () const

bool	has_default () const

bool	is_optional () const

bool	is_conditional () const

par_type	parameter_type () const

bool	should_use () const

	ParameterBase (Name const &name, Comment const &comment, par_style const vt, par_type const type, std::function< bool()> maybeUse=AlwaysUse())

virtual	~ParameterBase ()=default

void	set_value (fhicl::ParameterSet const &ps)

bool	preset_value (fhicl::ParameterSet const &ps)

void	set_par_style (par_style const vt)

Private Types
using	members_t = std::vector< cet::exempt_ptr< ParameterBase >>

Private Member Functions
	Table (ParameterSet const &, std::set< std::string > const &, Impl)

void	maybe_implicitly_default ()

members_t const &	get_members () const override

void	do_set_value (fhicl::ParameterSet const &pset) override

Private Member Functions inherited from fhicl::detail::RegisterIfTableMember
	RegisterIfTableMember (ParameterBase *pb)

Private Attributes
std::shared_ptr< T >	value_ {std::make_shared<T>()}

ParameterSet	pset_ {}

members_t	members_ {detail::TableMemberRegistry::release_members()}

Detailed Description

template<typename T, typename KeysToIgnore = void>
class fhicl::Table< T, KeysToIgnore >

Definition at line 30 of file type_traits.h.

Member Typedef Documentation

template<typename T, typename KeysToIgnore = void>

using fhicl::Table< T, KeysToIgnore >::default_type = T

Definition at line 82 of file Table.h.

template<typename T, typename KeysToIgnore = void>

using fhicl::Table< T, KeysToIgnore >::members_t = std::vector<cet::exempt_ptr<ParameterBase>>

private

Definition at line 86 of file Table.h.

template<typename T, typename KeysToIgnore = void>

using fhicl::Table< T, KeysToIgnore >::value_type = T

Definition at line 83 of file Table.h.

Constructor & Destructor Documentation

template<typename T , typename KeysToIgnore >

template<typename... TCARGS>

fhicl::Table< T, KeysToIgnore >::Table	(	Name &&	name,
		TCARGS &&...	tcargs
	)

explicit

Definition at line 128 of file Table.h.

129 : Table{std::move(name), Comment(""), std::forward<TCARGS>(tcargs)...}

130 {}

fhicl::detail::ParameterBase::name

std::string const & name() const

Definition: ParameterBase.h:43

fhicl::Table::Table

Table(Name &&name, TCARGS &&...tcargs)

Definition: Table.h:128

wirecell.gen.depos.move

def move(depos, offset)

Definition: depos.py:107

Comment

#define Comment

Definition: commentscan.cpp:4062

template<typename T , typename KeysToIgnore >

template<typename... TCARGS>

fhicl::Table< T, KeysToIgnore >::Table	(	Name &&	name,
		Comment &&	comment,
		TCARGS &&...	tcargs
	)

explicit

Definition at line 134 of file Table.h.

     : TableBase{std::move(name),
                 std::move(comment),
                 par_style::REQUIRED,
                 detail::AlwaysUse()}
     , RegisterIfTableMember{this}
     , value_{std::make_shared<T>(std::forward<TCARGS>(tcargs)...)}
   {
     maybe_implicitly_default();
     NameStackRegistry::end_of_ctor();
   }

template<typename T , typename KeysToIgnore >

template<typename... TCARGS>

fhicl::Table< T, KeysToIgnore >::Table	(	Name &&	name,
		Comment &&	comment,
		MaybeUseFunction	maybeUse,
		TCARGS &&...	tcargs
	)

explicit

Definition at line 150 of file Table.h.

     : TableBase{std::move(name),
                 std::move(comment),
                 par_style::REQUIRED_CONDITIONAL,
                 maybeUse}
     , RegisterIfTableMember{this}
     , value_{std::make_shared<T>(std::forward<TCARGS>(tcargs)...)}
   {
     maybe_implicitly_default();
     NameStackRegistry::end_of_ctor();
   }

template<typename T , typename KeysToIgnore >

template<typename , typename >

fhicl::Table< T, KeysToIgnore >::Table ( ParameterSet const & pset )

Definition at line 167 of file Table.h.

168 : Table{pset, KeysToIgnore{}(), Impl{}}

169 {}

fhicl::Table::Table

Table(Name &&name, TCARGS &&...tcargs)

Definition: Table.h:128

template<typename T , typename KeysToIgnore >

template<typename , typename >

fhicl::Table< T, KeysToIgnore >::Table	(	ParameterSet const &	pset,
		std::set< std::string > const &	keysToIgnore = `{}`
	)

Definition at line 173 of file Table.h.

175 : Table{pset, keysToIgnore, Impl{}}

176 {}

fhicl::Table::Table

Table(Name &&name, TCARGS &&...tcargs)

Definition: Table.h:128

template<typename T , typename KeysToIgnore >

fhicl::Table< T, KeysToIgnore >::Table	(	ParameterSet const &	pset,
		std::set< std::string > const &	keysToIgnore,
		Impl
	)

private

Definition at line 179 of file Table.h.

     : TableBase{Name("<top_level>"),
                 Comment(""),
                 par_style::REQUIRED,
                 detail::AlwaysUse()}
     , RegisterIfTableMember{this}
   {
     maybe_implicitly_default();
     NameStackRegistry::end_of_ctor();
     validate(pset, keysToIgnore);
   }

Member Function Documentation

template<typename T , typename KeysToIgnore >

void fhicl::Table< T, KeysToIgnore >::do_set_value ( fhicl::ParameterSet const & pset )

overrideprivatevirtual

Implements fhicl::detail::ParameterBase.

Definition at line 224 of file Table.h.

   {
     // Kind of tricky: we do not have the name of the current
     // parameter set.  A placeholder is often used (e.g. "<top_level>").
     // Fortunately, since the pset is passed in, we can just assign to
     // it for a top-level ParameterSet.  However, for nested parameter
     // sets, we need to trim off the placeholder, and then the key we
     // send pset.get<fhicl::ParameterSet>(key) is the key relative to
     // the top-level pset.
     std::string const& rkey = key();
     std::string const& nkey = detail::strip_first_containing_name(rkey);
     pset_ = (nkey == rkey) ? pset : pset.get<fhicl::ParameterSet>(nkey);
   }

template<typename T, typename KeysToIgnore = void>

members_t const& fhicl::Table< T, KeysToIgnore >::get_members ( ) const

inlineoverrideprivatevirtual

Implements fhicl::detail::TableBase.

Definition at line 97 of file Table.h.

     {
       return members_;
     }

template<typename T, typename KeysToIgnore = void>

ParameterSet const& fhicl::Table< T, KeysToIgnore >::get_PSet ( ) const

inline

Definition at line 68 of file Table.h.

     {
       return pset_;
     }

template<typename T , typename KeysToIgnore >

void fhicl::Table< T, KeysToIgnore >::maybe_implicitly_default ( )

private

Definition at line 240 of file Table.h.

   {
     bool const implicitly_default =
       std::all_of(members_.begin(), members_.end(), [](auto p) {
         return p->has_default() || p->is_optional();
       });
     if (implicitly_default)
       set_par_style(par_style::DEFAULT);
   }

template<typename T, typename KeysToIgnore = void>

auto const& fhicl::Table< T, KeysToIgnore >::operator() ( ) const

inline

Definition at line 62 of file Table.h.

     {
       return *value_;
     }

template<typename T , typename KeysToIgnore >

void fhicl::Table< T, KeysToIgnore >::print_allowed_configuration	(	std::ostream &	os,
		std::string const &	tab = `std::string(3, ' ')`
	)		const

Definition at line 213 of file Table.h.

   {
     os << '\n' << tab << detail::optional_parameter_message() << '\n';
     detail::PrintAllowedConfiguration pc{os, false, tab};
     pc.walk_over(*this);
   }

template<typename T , typename KeysToIgnore >

void fhicl::Table< T, KeysToIgnore >::validate	(	ParameterSet const &	pset,
		std::set< std::string > const &	keysToIgnore = `{}`
	)

Definition at line 195 of file Table.h.

   {
     pset_ = pset;
     detail::ValidateThenSet vs{pset_, keysToIgnore};
     cet::for_all(members(), [&vs](auto m) { vs.walk_over(*m); });
 
     try {
       vs.check_keys();
     }
     catch (fhicl::detail::validationException const&) {
       NameStackRegistry::clear();
       throw;
     }
   }

Member Data Documentation

template<typename T, typename KeysToIgnore = void>

members_t fhicl::Table< T, KeysToIgnore >::members_ {detail::TableMemberRegistry::release_members()}

private

Definition at line 90 of file Table.h.

template<typename T, typename KeysToIgnore = void>

ParameterSet fhicl::Table< T, KeysToIgnore >::pset_ {}

private

Definition at line 89 of file Table.h.

template<typename T, typename KeysToIgnore = void>

std::shared_ptr<T> fhicl::Table< T, KeysToIgnore >::value_ {std::make_shared<T>()}

private

Definition at line 88 of file Table.h.

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

fhiclcpp/fhiclcpp/type_traits.h
fhiclcpp/fhiclcpp/types/Table.h

Classes

Public Types

Public Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

template<typename T, typename KeysToIgnore = void> class fhicl::Table< T, KeysToIgnore >

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation

template<typename T, typename KeysToIgnore = void>
class fhicl::Table< T, KeysToIgnore >