Sequence.icc

Go to the documentation of this file.

#include "cetlib/container_algorithms.h"
#include "cetlib_except/demangle.h"
#include "fhiclcpp/detail/printing_helpers.h"
#include "fhiclcpp/types/detail/TableMemberRegistry.h"
#include "fhiclcpp/types/detail/ostream_helpers.h"
#include "fhiclcpp/types/detail/type_traits_error_msgs.h"
#include "fhiclcpp/type_traits.h"

#include <iostream>
#include <string>

namespace fhicl {

  //==================================================================
  // e.g. Sequence<int,4> ====> std::array<int,4>
  //

  template<typename T, std::size_t N>
  Sequence<T,N>::Sequence(Name&& name)
    : Sequence{std::move(name), Comment("")} {}

  template<typename T, std::size_t N>
  Sequence<T,N>::Sequence(Name&& name, Comment&& comment)
    : SequenceBase{std::move(name), std::move(comment), par_style::REQUIRED, par_type::SEQ_ARRAY, detail::AlwaysUse()}
    , RegisterIfTableMember{this}
    , value_{{nullptr}}
    {
      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>
  Sequence<T,N>::Sequence(Name&& name, Comment&& comment, std::function<bool()> maybeUse)
    : SequenceBase{std::move(name), std::move(comment), par_style::REQUIRED_CONDITIONAL, par_type::SEQ_ARRAY, maybeUse}
    , RegisterIfTableMember{this}
    , value_{{nullptr}}
    {
      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();
    }

  // c'tors that support defaults
  template<typename T, std::size_t N>
  Sequence<T,N>::Sequence(Name&& name, default_type const& defaults)
    : Sequence(std::move(name), Comment(""), defaults)
  {}

  template<typename T, std::size_t N>
  Sequence<T,N>::Sequence(Name&& name,
                          Comment&& comment,
                          default_type const& defaults)
    : SequenceBase{std::move(name), std::move(comment), par_style::DEFAULT, par_type::SEQ_ARRAY, detail::AlwaysUse()}
    , RegisterIfTableMember{this}
    , value_{{nullptr}}
    {
      std::size_t i{};
      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>
  Sequence<T,N>::Sequence(Name&& name,
                          Comment&& comment,
                          std::function<bool()> maybeUse,
                          default_type const& defaults)
    : SequenceBase{std::move(name), std::move(comment), par_style::DEFAULT_CONDITIONAL, par_type::SEQ_ARRAY, maybeUse}
    , RegisterIfTableMember{this}
    , value_{{nullptr}}
    {
      std::size_t i{};
      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();
    }

  //==================================================================
  // e.g. Sequence<int> ====> std::vector<int>
  //
  template<typename T>
  Sequence<T,-1ull>::Sequence(Name&& name)
    : Sequence{std::move(name), Comment("")}
    {}

  template<typename T>
  Sequence<T,-1ull>::Sequence(Name&& name, Comment&& comment)
    : SequenceBase{std::move(name), std::move(comment), par_style::REQUIRED, par_type::SEQ_VECTOR, detail::AlwaysUse()}
    , RegisterIfTableMember{this}
    , value_{{std::make_shared<tt::fhicl_type<T>>(Name::sequence_element(0ul))}}
    {
      NameStackRegistry::end_of_ctor();
    }

  template<typename T>
  Sequence<T,-1ull>::Sequence(Name&& name, Comment&& comment, std::function<bool()> maybeUse)
    : SequenceBase{std::move(name), std::move(comment), par_style::REQUIRED_CONDITIONAL, par_type::SEQ_VECTOR, maybeUse}
    , RegisterIfTableMember{this}
    , value_{{std::make_shared<tt::fhicl_type<T>>(Name::sequence_element(0ul))}}
    {
      NameStackRegistry::end_of_ctor();
    }

  // c'tors that support defaults
  template<typename T>
  Sequence<T,-1ull>::Sequence(Name&& name, default_type const& defaults)
    : Sequence{std::move(name), Comment(""), defaults}
    {}

  template<typename T>
  Sequence<T,-1ull>::Sequence (Name&& name, Comment&& comment, default_type const& defaults)
    : SequenceBase{std::move(name), std::move(comment), par_style::DEFAULT, par_type::SEQ_VECTOR, detail::AlwaysUse()}
    , RegisterIfTableMember{this}
  {
    static_assert(!tt::is_table<T>::value, NO_DEFAULTS_FOR_TABLE);
    std::size_t i{};
    for (auto const& t : defaults) {
      value_.emplace_back(new tt::fhicl_type<T>{Name::sequence_element(i), t});
      ++i;
    }
    NameStackRegistry::end_of_ctor();
  }


  template<typename T>
  Sequence<T,-1ull>::Sequence (Name&& name, Comment&& comment, std::function<bool()> maybeUse, default_type const& defaults)
    : SequenceBase{std::move(name), std::move(comment), par_style::DEFAULT_CONDITIONAL, par_type::SEQ_VECTOR, maybeUse}
    , RegisterIfTableMember{this}
  {
    static_assert(!tt::is_table<T>::value, NO_DEFAULTS_FOR_TABLE);
    std::size_t i{};
    for (auto const& t : defaults) {
      value_.emplace_back(new tt::fhicl_type<T>{Name::sequence_element(i), t});
      ++i;
    }
    NameStackRegistry::end_of_ctor();
  }

}

// Local variables:
// mode: c++
// End: