localization_nodes/include/localization_nodes/constraints.hpp

Go to the documentation of this file.

// Copyright 2021 Apex.AI, Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// Co-developed by Tier IV, Inc. and Apex.AI, Inc.

#ifndef LOCALIZATION_NODES__CONSTRAINTS_HPP_
#define LOCALIZATION_NODES__CONSTRAINTS_HPP_

#include <helper_functions/template_utils.hpp>
#include <localization_common/optimized_registration_summary.hpp>
#include <type_traits>
#include <string>

namespace autoware
{
namespace localization
{
namespace localization_nodes
{
enum class Requires
{
  Dummy
};
namespace traits
{
template<typename MapT, typename MapMsgT>
struct MapConstraint
{
  template<typename Map>
  using call_set = decltype(std::declval<Map>().set(std::declval<const MapMsgT &>()));

  template<typename Map>
  using call_frame_id = decltype(std::declval<Map>().frame_id());

  template<typename Map>
  using call_valid = decltype(std::declval<Map>().valid());

  static_assert(
    common::helper_functions::expression_valid<call_set, MapT>::value,
    "The map should provide a `set(msg)` method");
  static_assert(
    common::helper_functions::expression_valid_with_return<call_frame_id, MapT,
    const std::string &>::value,
    "The map should provide a `frame_id()` method");
  static_assert(
    common::helper_functions::expression_valid_with_return<call_valid, MapT, bool>::value,
    "The map should provide a `valid(msg)` method");
  static constexpr Requires value{};
};

template<typename LocalizerT, typename InputT, typename MapT,
  typename SummaryT = localization_common::OptimizedRegistrationSummary>
struct LocalizerConstraint
{
  template<typename Localizer>
  using call_register = decltype(std::declval<Localizer>().register_measurement(
      std::declval<InputT>(),
      std::declval<geometry_msgs::msg::TransformStamped>(),
      std::declval<MapT>(),
      std::declval<SummaryT * const>())
  );

  static_assert(
    common::helper_functions::expression_valid_with_return<
      call_register, LocalizerT, geometry_msgs::msg::PoseWithCovarianceStamped>::value,
    "The localizer should provide a valid  `register_measurement(...)` method.");
  static constexpr Requires value{};
};
// External definition of static members:
template<typename MapT, typename MapMsgT>
constexpr Requires MapConstraint<MapT, MapMsgT>::value;
template<typename LocalizerT, typename InputT, typename MapT, typename SummaryT>
constexpr Requires LocalizerConstraint<LocalizerT, InputT, MapT, SummaryT>::value;
}  // namespace traits
}  // namespace localization_nodes
}  // namespace localization
}  // namespace autoware
#endif  // LOCALIZATION_NODES__CONSTRAINTS_HPP_