fhicl::Sequence< T, N > Class Template Reference

#include <type_traits.h>

Inheritance diagram for fhicl::Sequence< T, N >:

Public Types
using	default_type = sequence_detail::ValueHolder< typename tt::fhicl_type< T >::default_type >
using	ftype = std::array< std::shared_ptr< tt::fhicl_type< T >>, N >
using	value_type = std::array< tt::return_type< T >, N >

Public Member Functions
	Sequence (Name &&name)
	Sequence (Name &&name, Comment &&comment)
	Sequence (Name &&name, Comment &&comment, std::function< bool()> maybeUse)
	Sequence (Name &&name, default_type const &defaults)
	Sequence (Name &&name, Comment &&comment, default_type const &defaults)
	Sequence (Name &&name, Comment &&comment, std::function< bool()> maybeUse, default_type const &defaults)
auto	operator() () const
auto	operator() (std::size_t const i) const
Public Member Functions inherited from fhicl::detail::SequenceBase
	SequenceBase (Name &&name, Comment &&comment, par_style const vt, par_type const type, std::function< bool()> maybeUse)
bool	empty () const noexcept
std::size_t	size () const noexcept
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
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 Member Functions
std::size_t	get_size () const noexcept override
void	do_prepare_elements_for_validation (std::size_t const n) override
void	do_walk_elements (detail::ParameterWalker< tt::const_flavor::require_non_const > &pw) override
void	do_walk_elements (detail::ParameterWalker< tt::const_flavor::require_const > &pw) const override
bool	do_preset_value (fhicl::ParameterSet const &ps) override
void	do_set_value (fhicl::ParameterSet const &) override
Private Member Functions inherited from fhicl::detail::RegisterIfTableMember
	RegisterIfTableMember (ParameterBase *pb)

Private Attributes
std::variant< ftype, value_type >	value_

Detailed Description

template<typename T, std::size_t N = -1ull>
class fhicl::Sequence< T, N >

Definition at line 43 of file type_traits.h.

Member Typedef Documentation

template<typename T, std::size_t N = -1ull>

using fhicl::Sequence< T, N >::default_type = sequence_detail::ValueHolder<typename tt::fhicl_type<T>::default_type>

Definition at line 83 of file Sequence.h.

template<typename T, std::size_t N = -1ull>

using fhicl::Sequence< T, N >::ftype = std::array<std::shared_ptr<tt::fhicl_type<T>>, N>

Definition at line 84 of file Sequence.h.

template<typename T, std::size_t N = -1ull>

using fhicl::Sequence< T, N >::value_type = std::array<tt::return_type<T>, N>

Definition at line 85 of file Sequence.h.

Constructor & Destructor Documentation

template<typename T , std::size_t N>

fhicl::Sequence< T, N >::Sequence ( Name &&  name )

explicit

Definition at line 326 of file Sequence.h.

                                      : Sequence{std::move(name), Comment("")}
  {}

template<typename T , std::size_t N>

fhicl::Sequence< T, N >::Sequence ( Name &&  name, Comment &&  comment  )

explicit

Definition at line 330 of file Sequence.h.

    : SequenceBase{std::move(name),
                   std::move(comment),
                   par_style::REQUIRED,
                   par_type::SEQ_ARRAY,
                   detail::AlwaysUse()}
    , RegisterIfTableMember{this}
    , value_{ftype{nullptr}}
  {
    auto& value = std::get<ftype>(value_);
    for (std::size_t i{}; i != N; ++i) {
      value.at(i) =
        std::make_shared<tt::fhicl_type<T>>(Name::sequence_element(i));
    }
    NameStackRegistry::end_of_ctor();
  }

template<typename T , std::size_t N>

fhicl::Sequence< T, N >::Sequence ( Name &&  name, Comment &&  comment, std::function< bool()>  maybeUse  )

explicit

Definition at line 348 of file Sequence.h.

    : SequenceBase{std::move(name),
                   std::move(comment),
                   par_style::REQUIRED_CONDITIONAL,
                   par_type::SEQ_ARRAY,
                   maybeUse}
    , RegisterIfTableMember{this}
    , value_{ftype{nullptr}}
  {
    auto& value = std::get<ftype>(value_);
    for (std::size_t i{}; i != N; ++i) {
      value.at(i) =
        std::make_shared<tt::fhicl_type<T>>(Name::sequence_element(i));
    }
    NameStackRegistry::end_of_ctor();
  }

template<typename T , std::size_t N>

fhicl::Sequence< T, N >::Sequence ( Name &&  name, default_type const &  defaults  )

explicit

Definition at line 369 of file Sequence.h.

    : Sequence{std::move(name), Comment{""}, defaults}
  {}

template<typename T , std::size_t N>

fhicl::Sequence< T, N >::Sequence ( Name &&  name, Comment &&  comment, default_type const &  defaults  )

explicit

Definition at line 374 of file Sequence.h.

    : SequenceBase{std::move(name),
                   std::move(comment),
                   par_style::DEFAULT,
                   par_type::SEQ_ARRAY,
                   detail::AlwaysUse()}
    , RegisterIfTableMember{this}
    , value_{ftype{nullptr}}
  {
    std::size_t i{};
    auto& value = std::get<ftype>(value_);
    for (auto const& arg : defaults) {
      value.at(i) =
        std::make_shared<tt::fhicl_type<T>>(Name::sequence_element(i), arg);
      ++i;
    }
    NameStackRegistry::end_of_ctor();
  }

template<typename T , std::size_t N>

fhicl::Sequence< T, N >::Sequence ( Name &&  name, Comment &&  comment, std::function< bool()>  maybeUse, default_type const &  defaults  )

explicit

Definition at line 396 of file Sequence.h.

    : SequenceBase{std::move(name),
                   std::move(comment),
                   par_style::DEFAULT_CONDITIONAL,
                   par_type::SEQ_ARRAY,
                   maybeUse}
    , RegisterIfTableMember{this}
    , value_{ftype{nullptr}}
  {
    std::size_t i{};
    auto& value = std::get<ftype>(value_);
    for (auto const& arg : defaults) {
      value.at(i) =
        std::make_shared<tt::fhicl_type<T>>(Name::sequence_element(i), arg);
      ++i;
    }
    NameStackRegistry::end_of_ctor();
  }

Member Function Documentation

template<typename T, std::size_t N = -1ull>

void fhicl::Sequence< T, N >::do_prepare_elements_for_validation ( std::size_t const  n )

inlineoverrideprivatevirtual

Implements fhicl::detail::SequenceBase.

Definition at line 138 of file Sequence.h.

    {
      detail::check_nargs_for_bounded_sequences(key(), get_size(), n);
    }

template<typename T, std::size_t N = -1ull>

bool fhicl::Sequence< T, N >::do_preset_value ( fhicl::ParameterSet const &  ps )

inlineoverrideprivatevirtual

Reimplemented from fhicl::detail::ParameterBase.

Definition at line 162 of file Sequence.h.

    {
      if constexpr (std::is_same_v<tt::fhicl_type<T>, Atom<T>>) {
        auto const trimmed_key = detail::strip_first_containing_name(key());
        value_ = ps.get<value_type>(trimmed_key);
        return true;
      }
      return false;
    }

template<typename T, std::size_t N = -1ull>

void fhicl::Sequence< T, N >::do_set_value ( fhicl::ParameterSet const &  )

inlineoverrideprivatevirtual

Implements fhicl::detail::ParameterBase.

Definition at line 173 of file Sequence.h.

    {}

template<typename T, std::size_t N = -1ull>

void fhicl::Sequence< T, N >::do_walk_elements ( detail::ParameterWalker< tt::const_flavor::require_non_const > &  pw )

inlineoverrideprivatevirtual

Implements fhicl::detail::SequenceBase.

Definition at line 144 of file Sequence.h.

    {
      // We only enter here if we do not have a preset value.
      cet::for_all(std::get<ftype>(value_),
                   [&pw](auto& e) { pw.walk_over(*e); });
    }

template<typename T, std::size_t N = -1ull>

void fhicl::Sequence< T, N >::do_walk_elements ( detail::ParameterWalker< tt::const_flavor::require_const > &  pw ) const

inlineoverrideprivatevirtual

Implements fhicl::detail::SequenceBase.

Definition at line 153 of file Sequence.h.

    {
      // We only enter here if we do not have a preset value.
      cet::for_all(std::get<ftype>(value_),
                   [&pw](auto const& e) { pw.walk_over(*e); });
    }

template<typename T, std::size_t N = -1ull>

std::size_t fhicl::Sequence< T, N >::get_size ( ) const

inlineoverrideprivatevirtualnoexcept

Implements fhicl::detail::SequenceBase.

Definition at line 129 of file Sequence.h.

    {
      if (auto value = std::get_if<value_type>(&value_)) {
        return value->size();
      }
      return std::get<ftype>(value_).size();
    }

template<typename T, std::size_t N = -1ull>

auto fhicl::Sequence< T, N >::operator() ( ) const

inline

Definition at line 104 of file Sequence.h.

    {
      if (auto value = std::get_if<value_type>(&value_)) {
        return *value;
      }
      value_type result = {{tt::return_type<T>()}};
      cet::transform_all(std::get<ftype>(value_),
                         result.begin(),
                         [](auto const& elem) { return (*elem)(); });
      return result;
    }

template<typename T, std::size_t N = -1ull>

auto fhicl::Sequence< T, N >::operator() ( std::size_t const  i ) const

inline

Definition at line 117 of file Sequence.h.

    {
      if (auto value = std::get_if<value_type>(&value_)) {
        return value->at(i);
      }
      return (*std::get<ftype>(value_).at(i))();
    }

Member Data Documentation

template<typename T, std::size_t N = -1ull>

std::variant<ftype, value_type> fhicl::Sequence< T, N >::value_

private

Definition at line 126 of file Sequence.h.

---

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

• fhiclcpp/fhiclcpp/type_traits.h
• fhiclcpp/fhiclcpp/types/Sequence.h