ProperResponse.hpp

Go to the documentation of this file.

/*
 * ----------------- BEGIN LICENSE BLOCK ---------------------------------
 *
 * Copyright (C) 2018-2022 Intel Corporation
 *
 * SPDX-License-Identifier: LGPL-2.1-only
 *
 * ----------------- END LICENSE BLOCK -----------------------------------
 */
 
#pragma once
 
#include <iostream>
#include <limits>
#include <memory>
#include <sstream>
#include "ad/geometry/HeadingRangeVector.hpp"
#include "ad/rss/state/AccelerationRestriction.hpp"
#include "ad/rss/state/LateralResponse.hpp"
#include "ad/rss/state/LongitudinalResponse.hpp"
#include "ad/rss/state/UnstructuredConstellationResponse.hpp"
#include "ad/rss/world/ObjectIdVector.hpp"
#include "ad/rss/world/TimeIndex.hpp"
namespace ad {
namespace rss {
namespace state {
 
struct ProperResponse
{
  typedef std::shared_ptr<ProperResponse> Ptr;
 
  typedef std::shared_ptr<ProperResponse const> ConstPtr;
 
  ProperResponse() = default;
 
  ~ProperResponse() = default;
 
  ProperResponse(const ProperResponse &other) = default;
 
  ProperResponse(ProperResponse &&other) = default;
 
  ProperResponse &operator=(const ProperResponse &other) = default;
 
  ProperResponse &operator=(ProperResponse &&other) = default;
 
  bool operator==(const ProperResponse &other) const
  {
    return (time_index == other.time_index) && (is_safe == other.is_safe)
      && (dangerous_objects == other.dangerous_objects) && (longitudinal_response == other.longitudinal_response)
      && (lateral_response_right == other.lateral_response_right)
      && (lateral_response_left == other.lateral_response_left) && (heading_ranges == other.heading_ranges)
      && (acceleration_restrictions == other.acceleration_restrictions)
      && (unstructured_constellation_response == other.unstructured_constellation_response);
  }
 
  bool operator!=(const ProperResponse &other) const
  {
    return !operator==(other);
  }
 
  ::ad::rss::world::TimeIndex time_index{0u};
 
  bool is_safe{false};
 
  ::ad::rss::world::ObjectIdVector dangerous_objects;
 
  ::ad::rss::state::LongitudinalResponse longitudinal_response;
 
  ::ad::rss::state::LateralResponse lateral_response_right;
 
  ::ad::rss::state::LateralResponse lateral_response_left;
 
  ::ad::geometry::HeadingRangeVector heading_ranges;
 
  ::ad::rss::state::AccelerationRestriction acceleration_restrictions;
 
  ::ad::rss::state::UnstructuredConstellationResponse unstructured_constellation_response;
};
 
} // namespace state
} // namespace rss
} // namespace ad
 
#ifndef GEN_GUARD_AD_RSS_STATE_PROPERRESPONSE
#define GEN_GUARD_AD_RSS_STATE_PROPERRESPONSE
namespace ad {
namespace rss {
namespace state {
 
inline std::ostream &operator<<(std::ostream &os, ProperResponse const &_value)
{
  os << "ProperResponse(";
  os << "time_index:";
  os << _value.time_index;
  os << ",";
  os << "is_safe:";
  os << _value.is_safe;
  os << ",";
  os << "dangerous_objects:";
  os << _value.dangerous_objects;
  os << ",";
  os << "longitudinal_response:";
  os << _value.longitudinal_response;
  os << ",";
  os << "lateral_response_right:";
  os << _value.lateral_response_right;
  os << ",";
  os << "lateral_response_left:";
  os << _value.lateral_response_left;
  os << ",";
  os << "heading_ranges:";
  os << _value.heading_ranges;
  os << ",";
  os << "acceleration_restrictions:";
  os << _value.acceleration_restrictions;
  os << ",";
  os << "unstructured_constellation_response:";
  os << _value.unstructured_constellation_response;
  os << ")";
  return os;
}
 
} // namespace state
} // namespace rss
} // namespace ad
 
namespace std {
inline std::string to_string(::ad::rss::state::ProperResponse const &value)
{
  stringstream sstream;
  sstream << value;
  return sstream.str();
}
} // namespace std
 
template <> struct fmt::formatter<::ad::rss::state::ProperResponse> : formatter<string_view>
{
  template <typename FormatContext> auto format(::ad::rss::state::ProperResponse const &value, FormatContext &ctx)
  {
    return formatter<string_view>::format(std::to_string(value), ctx);
  }
};
 
#endif // GEN_GUARD_AD_RSS_STATE_PROPERRESPONSE