// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: second/protos/box_coder.proto

#ifndef GOOGLE_PROTOBUF_INCLUDED_second_2fprotos_2fbox_5fcoder_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_second_2fprotos_2fbox_5fcoder_2eproto

#include <limits>
#include <string>

#include <google/protobuf/port_def.inc>
#if PROTOBUF_VERSION < 3021000
#error This file was generated by a newer version of protoc which is
#error incompatible with your Protocol Buffer headers. Please update
#error your headers.
#endif
#if 3021005 < PROTOBUF_MIN_PROTOC_VERSION
#error This file was generated by an older version of protoc which is
#error incompatible with your Protocol Buffer headers. Please
#error regenerate this file with a newer version of protoc.
#endif

#include <google/protobuf/port_undef.inc>
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/arena.h>
#include <google/protobuf/arenastring.h>
#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/metadata_lite.h>
#include <google/protobuf/generated_message_reflection.h>
#include <google/protobuf/message.h>
#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
#include <google/protobuf/extension_set.h>  // IWYU pragma: export
#include <google/protobuf/unknown_field_set.h>
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_second_2fprotos_2fbox_5fcoder_2eproto
PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
}  // namespace internal
PROTOBUF_NAMESPACE_CLOSE

// Internal implementation detail -- do not use these members.
struct TableStruct_second_2fprotos_2fbox_5fcoder_2eproto {
  static const uint32_t offsets[];
};
extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_second_2fprotos_2fbox_5fcoder_2eproto;
namespace second {
namespace protos {
class BevBoxCoder;
struct BevBoxCoderDefaultTypeInternal;
extern BevBoxCoderDefaultTypeInternal _BevBoxCoder_default_instance_;
class BoxCoder;
struct BoxCoderDefaultTypeInternal;
extern BoxCoderDefaultTypeInternal _BoxCoder_default_instance_;
class GroundBox3dCoder;
struct GroundBox3dCoderDefaultTypeInternal;
extern GroundBox3dCoderDefaultTypeInternal _GroundBox3dCoder_default_instance_;
}  // namespace protos
}  // namespace second
PROTOBUF_NAMESPACE_OPEN
template<> ::second::protos::BevBoxCoder* Arena::CreateMaybeMessage<::second::protos::BevBoxCoder>(Arena*);
template<> ::second::protos::BoxCoder* Arena::CreateMaybeMessage<::second::protos::BoxCoder>(Arena*);
template<> ::second::protos::GroundBox3dCoder* Arena::CreateMaybeMessage<::second::protos::GroundBox3dCoder>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace second {
namespace protos {

// ===================================================================

class BoxCoder final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:second.protos.BoxCoder) */ {
 public:
  inline BoxCoder() : BoxCoder(nullptr) {}
  ~BoxCoder() override;
  explicit PROTOBUF_CONSTEXPR BoxCoder(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  BoxCoder(const BoxCoder& from);
  BoxCoder(BoxCoder&& from) noexcept
    : BoxCoder() {
    *this = ::std::move(from);
  }

  inline BoxCoder& operator=(const BoxCoder& from) {
    CopyFrom(from);
    return *this;
  }
  inline BoxCoder& operator=(BoxCoder&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const BoxCoder& default_instance() {
    return *internal_default_instance();
  }
  enum BoxCoderCase {
    kGroundBox3DCoder = 1,
    kBevBoxCoder = 2,
    BOX_CODER_NOT_SET = 0,
  };

  static inline const BoxCoder* internal_default_instance() {
    return reinterpret_cast<const BoxCoder*>(
               &_BoxCoder_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    0;

  friend void swap(BoxCoder& a, BoxCoder& b) {
    a.Swap(&b);
  }
  inline void Swap(BoxCoder* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(BoxCoder* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  BoxCoder* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<BoxCoder>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const BoxCoder& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const BoxCoder& from) {
    BoxCoder::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(BoxCoder* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "second.protos.BoxCoder";
  }
  protected:
  explicit BoxCoder(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kGroundBox3DCoderFieldNumber = 1,
    kBevBoxCoderFieldNumber = 2,
  };
  // .second.protos.GroundBox3dCoder ground_box3d_coder = 1;
  bool has_ground_box3d_coder() const;
  private:
  bool _internal_has_ground_box3d_coder() const;
  public:
  void clear_ground_box3d_coder();
  const ::second::protos::GroundBox3dCoder& ground_box3d_coder() const;
  PROTOBUF_NODISCARD ::second::protos::GroundBox3dCoder* release_ground_box3d_coder();
  ::second::protos::GroundBox3dCoder* mutable_ground_box3d_coder();
  void set_allocated_ground_box3d_coder(::second::protos::GroundBox3dCoder* ground_box3d_coder);
  private:
  const ::second::protos::GroundBox3dCoder& _internal_ground_box3d_coder() const;
  ::second::protos::GroundBox3dCoder* _internal_mutable_ground_box3d_coder();
  public:
  void unsafe_arena_set_allocated_ground_box3d_coder(
      ::second::protos::GroundBox3dCoder* ground_box3d_coder);
  ::second::protos::GroundBox3dCoder* unsafe_arena_release_ground_box3d_coder();

  // .second.protos.BevBoxCoder bev_box_coder = 2;
  bool has_bev_box_coder() const;
  private:
  bool _internal_has_bev_box_coder() const;
  public:
  void clear_bev_box_coder();
  const ::second::protos::BevBoxCoder& bev_box_coder() const;
  PROTOBUF_NODISCARD ::second::protos::BevBoxCoder* release_bev_box_coder();
  ::second::protos::BevBoxCoder* mutable_bev_box_coder();
  void set_allocated_bev_box_coder(::second::protos::BevBoxCoder* bev_box_coder);
  private:
  const ::second::protos::BevBoxCoder& _internal_bev_box_coder() const;
  ::second::protos::BevBoxCoder* _internal_mutable_bev_box_coder();
  public:
  void unsafe_arena_set_allocated_bev_box_coder(
      ::second::protos::BevBoxCoder* bev_box_coder);
  ::second::protos::BevBoxCoder* unsafe_arena_release_bev_box_coder();

  void clear_box_coder();
  BoxCoderCase box_coder_case() const;
  // @@protoc_insertion_point(class_scope:second.protos.BoxCoder)
 private:
  class _Internal;
  void set_has_ground_box3d_coder();
  void set_has_bev_box_coder();

  inline bool has_box_coder() const;
  inline void clear_has_box_coder();

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    union BoxCoderUnion {
      constexpr BoxCoderUnion() : _constinit_{} {}
        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
      ::second::protos::GroundBox3dCoder* ground_box3d_coder_;
      ::second::protos::BevBoxCoder* bev_box_coder_;
    } box_coder_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    uint32_t _oneof_case_[1];

  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_second_2fprotos_2fbox_5fcoder_2eproto;
};
// -------------------------------------------------------------------

class GroundBox3dCoder final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:second.protos.GroundBox3dCoder) */ {
 public:
  inline GroundBox3dCoder() : GroundBox3dCoder(nullptr) {}
  ~GroundBox3dCoder() override;
  explicit PROTOBUF_CONSTEXPR GroundBox3dCoder(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  GroundBox3dCoder(const GroundBox3dCoder& from);
  GroundBox3dCoder(GroundBox3dCoder&& from) noexcept
    : GroundBox3dCoder() {
    *this = ::std::move(from);
  }

  inline GroundBox3dCoder& operator=(const GroundBox3dCoder& from) {
    CopyFrom(from);
    return *this;
  }
  inline GroundBox3dCoder& operator=(GroundBox3dCoder&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const GroundBox3dCoder& default_instance() {
    return *internal_default_instance();
  }
  static inline const GroundBox3dCoder* internal_default_instance() {
    return reinterpret_cast<const GroundBox3dCoder*>(
               &_GroundBox3dCoder_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    1;

  friend void swap(GroundBox3dCoder& a, GroundBox3dCoder& b) {
    a.Swap(&b);
  }
  inline void Swap(GroundBox3dCoder* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(GroundBox3dCoder* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  GroundBox3dCoder* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<GroundBox3dCoder>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const GroundBox3dCoder& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const GroundBox3dCoder& from) {
    GroundBox3dCoder::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(GroundBox3dCoder* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "second.protos.GroundBox3dCoder";
  }
  protected:
  explicit GroundBox3dCoder(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kLinearDimFieldNumber = 1,
    kEncodeAngleVectorFieldNumber = 2,
  };
  // bool linear_dim = 1;
  void clear_linear_dim();
  bool linear_dim() const;
  void set_linear_dim(bool value);
  private:
  bool _internal_linear_dim() const;
  void _internal_set_linear_dim(bool value);
  public:

  // bool encode_angle_vector = 2;
  void clear_encode_angle_vector();
  bool encode_angle_vector() const;
  void set_encode_angle_vector(bool value);
  private:
  bool _internal_encode_angle_vector() const;
  void _internal_set_encode_angle_vector(bool value);
  public:

  // @@protoc_insertion_point(class_scope:second.protos.GroundBox3dCoder)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    bool linear_dim_;
    bool encode_angle_vector_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_second_2fprotos_2fbox_5fcoder_2eproto;
};
// -------------------------------------------------------------------

class BevBoxCoder final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:second.protos.BevBoxCoder) */ {
 public:
  inline BevBoxCoder() : BevBoxCoder(nullptr) {}
  ~BevBoxCoder() override;
  explicit PROTOBUF_CONSTEXPR BevBoxCoder(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  BevBoxCoder(const BevBoxCoder& from);
  BevBoxCoder(BevBoxCoder&& from) noexcept
    : BevBoxCoder() {
    *this = ::std::move(from);
  }

  inline BevBoxCoder& operator=(const BevBoxCoder& from) {
    CopyFrom(from);
    return *this;
  }
  inline BevBoxCoder& operator=(BevBoxCoder&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const BevBoxCoder& default_instance() {
    return *internal_default_instance();
  }
  static inline const BevBoxCoder* internal_default_instance() {
    return reinterpret_cast<const BevBoxCoder*>(
               &_BevBoxCoder_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    2;

  friend void swap(BevBoxCoder& a, BevBoxCoder& b) {
    a.Swap(&b);
  }
  inline void Swap(BevBoxCoder* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(BevBoxCoder* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  BevBoxCoder* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<BevBoxCoder>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const BevBoxCoder& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const BevBoxCoder& from) {
    BevBoxCoder::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(BevBoxCoder* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "second.protos.BevBoxCoder";
  }
  protected:
  explicit BevBoxCoder(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kLinearDimFieldNumber = 1,
    kEncodeAngleVectorFieldNumber = 2,
    kZFixedFieldNumber = 3,
    kHFixedFieldNumber = 4,
  };
  // bool linear_dim = 1;
  void clear_linear_dim();
  bool linear_dim() const;
  void set_linear_dim(bool value);
  private:
  bool _internal_linear_dim() const;
  void _internal_set_linear_dim(bool value);
  public:

  // bool encode_angle_vector = 2;
  void clear_encode_angle_vector();
  bool encode_angle_vector() const;
  void set_encode_angle_vector(bool value);
  private:
  bool _internal_encode_angle_vector() const;
  void _internal_set_encode_angle_vector(bool value);
  public:

  // float z_fixed = 3;
  void clear_z_fixed();
  float z_fixed() const;
  void set_z_fixed(float value);
  private:
  float _internal_z_fixed() const;
  void _internal_set_z_fixed(float value);
  public:

  // float h_fixed = 4;
  void clear_h_fixed();
  float h_fixed() const;
  void set_h_fixed(float value);
  private:
  float _internal_h_fixed() const;
  void _internal_set_h_fixed(float value);
  public:

  // @@protoc_insertion_point(class_scope:second.protos.BevBoxCoder)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    bool linear_dim_;
    bool encode_angle_vector_;
    float z_fixed_;
    float h_fixed_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_second_2fprotos_2fbox_5fcoder_2eproto;
};
// ===================================================================


// ===================================================================

#ifdef __GNUC__
  #pragma GCC diagnostic push
  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
#endif  // __GNUC__
// BoxCoder

// .second.protos.GroundBox3dCoder ground_box3d_coder = 1;
inline bool BoxCoder::_internal_has_ground_box3d_coder() const {
  return box_coder_case() == kGroundBox3DCoder;
}
inline bool BoxCoder::has_ground_box3d_coder() const {
  return _internal_has_ground_box3d_coder();
}
inline void BoxCoder::set_has_ground_box3d_coder() {
  _impl_._oneof_case_[0] = kGroundBox3DCoder;
}
inline void BoxCoder::clear_ground_box3d_coder() {
  if (_internal_has_ground_box3d_coder()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.box_coder_.ground_box3d_coder_;
    }
    clear_has_box_coder();
  }
}
inline ::second::protos::GroundBox3dCoder* BoxCoder::release_ground_box3d_coder() {
  // @@protoc_insertion_point(field_release:second.protos.BoxCoder.ground_box3d_coder)
  if (_internal_has_ground_box3d_coder()) {
    clear_has_box_coder();
    ::second::protos::GroundBox3dCoder* temp = _impl_.box_coder_.ground_box3d_coder_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.box_coder_.ground_box3d_coder_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::second::protos::GroundBox3dCoder& BoxCoder::_internal_ground_box3d_coder() const {
  return _internal_has_ground_box3d_coder()
      ? *_impl_.box_coder_.ground_box3d_coder_
      : reinterpret_cast< ::second::protos::GroundBox3dCoder&>(::second::protos::_GroundBox3dCoder_default_instance_);
}
inline const ::second::protos::GroundBox3dCoder& BoxCoder::ground_box3d_coder() const {
  // @@protoc_insertion_point(field_get:second.protos.BoxCoder.ground_box3d_coder)
  return _internal_ground_box3d_coder();
}
inline ::second::protos::GroundBox3dCoder* BoxCoder::unsafe_arena_release_ground_box3d_coder() {
  // @@protoc_insertion_point(field_unsafe_arena_release:second.protos.BoxCoder.ground_box3d_coder)
  if (_internal_has_ground_box3d_coder()) {
    clear_has_box_coder();
    ::second::protos::GroundBox3dCoder* temp = _impl_.box_coder_.ground_box3d_coder_;
    _impl_.box_coder_.ground_box3d_coder_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void BoxCoder::unsafe_arena_set_allocated_ground_box3d_coder(::second::protos::GroundBox3dCoder* ground_box3d_coder) {
  clear_box_coder();
  if (ground_box3d_coder) {
    set_has_ground_box3d_coder();
    _impl_.box_coder_.ground_box3d_coder_ = ground_box3d_coder;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:second.protos.BoxCoder.ground_box3d_coder)
}
inline ::second::protos::GroundBox3dCoder* BoxCoder::_internal_mutable_ground_box3d_coder() {
  if (!_internal_has_ground_box3d_coder()) {
    clear_box_coder();
    set_has_ground_box3d_coder();
    _impl_.box_coder_.ground_box3d_coder_ = CreateMaybeMessage< ::second::protos::GroundBox3dCoder >(GetArenaForAllocation());
  }
  return _impl_.box_coder_.ground_box3d_coder_;
}
inline ::second::protos::GroundBox3dCoder* BoxCoder::mutable_ground_box3d_coder() {
  ::second::protos::GroundBox3dCoder* _msg = _internal_mutable_ground_box3d_coder();
  // @@protoc_insertion_point(field_mutable:second.protos.BoxCoder.ground_box3d_coder)
  return _msg;
}

// .second.protos.BevBoxCoder bev_box_coder = 2;
inline bool BoxCoder::_internal_has_bev_box_coder() const {
  return box_coder_case() == kBevBoxCoder;
}
inline bool BoxCoder::has_bev_box_coder() const {
  return _internal_has_bev_box_coder();
}
inline void BoxCoder::set_has_bev_box_coder() {
  _impl_._oneof_case_[0] = kBevBoxCoder;
}
inline void BoxCoder::clear_bev_box_coder() {
  if (_internal_has_bev_box_coder()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.box_coder_.bev_box_coder_;
    }
    clear_has_box_coder();
  }
}
inline ::second::protos::BevBoxCoder* BoxCoder::release_bev_box_coder() {
  // @@protoc_insertion_point(field_release:second.protos.BoxCoder.bev_box_coder)
  if (_internal_has_bev_box_coder()) {
    clear_has_box_coder();
    ::second::protos::BevBoxCoder* temp = _impl_.box_coder_.bev_box_coder_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.box_coder_.bev_box_coder_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::second::protos::BevBoxCoder& BoxCoder::_internal_bev_box_coder() const {
  return _internal_has_bev_box_coder()
      ? *_impl_.box_coder_.bev_box_coder_
      : reinterpret_cast< ::second::protos::BevBoxCoder&>(::second::protos::_BevBoxCoder_default_instance_);
}
inline const ::second::protos::BevBoxCoder& BoxCoder::bev_box_coder() const {
  // @@protoc_insertion_point(field_get:second.protos.BoxCoder.bev_box_coder)
  return _internal_bev_box_coder();
}
inline ::second::protos::BevBoxCoder* BoxCoder::unsafe_arena_release_bev_box_coder() {
  // @@protoc_insertion_point(field_unsafe_arena_release:second.protos.BoxCoder.bev_box_coder)
  if (_internal_has_bev_box_coder()) {
    clear_has_box_coder();
    ::second::protos::BevBoxCoder* temp = _impl_.box_coder_.bev_box_coder_;
    _impl_.box_coder_.bev_box_coder_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void BoxCoder::unsafe_arena_set_allocated_bev_box_coder(::second::protos::BevBoxCoder* bev_box_coder) {
  clear_box_coder();
  if (bev_box_coder) {
    set_has_bev_box_coder();
    _impl_.box_coder_.bev_box_coder_ = bev_box_coder;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:second.protos.BoxCoder.bev_box_coder)
}
inline ::second::protos::BevBoxCoder* BoxCoder::_internal_mutable_bev_box_coder() {
  if (!_internal_has_bev_box_coder()) {
    clear_box_coder();
    set_has_bev_box_coder();
    _impl_.box_coder_.bev_box_coder_ = CreateMaybeMessage< ::second::protos::BevBoxCoder >(GetArenaForAllocation());
  }
  return _impl_.box_coder_.bev_box_coder_;
}
inline ::second::protos::BevBoxCoder* BoxCoder::mutable_bev_box_coder() {
  ::second::protos::BevBoxCoder* _msg = _internal_mutable_bev_box_coder();
  // @@protoc_insertion_point(field_mutable:second.protos.BoxCoder.bev_box_coder)
  return _msg;
}

inline bool BoxCoder::has_box_coder() const {
  return box_coder_case() != BOX_CODER_NOT_SET;
}
inline void BoxCoder::clear_has_box_coder() {
  _impl_._oneof_case_[0] = BOX_CODER_NOT_SET;
}
inline BoxCoder::BoxCoderCase BoxCoder::box_coder_case() const {
  return BoxCoder::BoxCoderCase(_impl_._oneof_case_[0]);
}
// -------------------------------------------------------------------

// GroundBox3dCoder

// bool linear_dim = 1;
inline void GroundBox3dCoder::clear_linear_dim() {
  _impl_.linear_dim_ = false;
}
inline bool GroundBox3dCoder::_internal_linear_dim() const {
  return _impl_.linear_dim_;
}
inline bool GroundBox3dCoder::linear_dim() const {
  // @@protoc_insertion_point(field_get:second.protos.GroundBox3dCoder.linear_dim)
  return _internal_linear_dim();
}
inline void GroundBox3dCoder::_internal_set_linear_dim(bool value) {
  
  _impl_.linear_dim_ = value;
}
inline void GroundBox3dCoder::set_linear_dim(bool value) {
  _internal_set_linear_dim(value);
  // @@protoc_insertion_point(field_set:second.protos.GroundBox3dCoder.linear_dim)
}

// bool encode_angle_vector = 2;
inline void GroundBox3dCoder::clear_encode_angle_vector() {
  _impl_.encode_angle_vector_ = false;
}
inline bool GroundBox3dCoder::_internal_encode_angle_vector() const {
  return _impl_.encode_angle_vector_;
}
inline bool GroundBox3dCoder::encode_angle_vector() const {
  // @@protoc_insertion_point(field_get:second.protos.GroundBox3dCoder.encode_angle_vector)
  return _internal_encode_angle_vector();
}
inline void GroundBox3dCoder::_internal_set_encode_angle_vector(bool value) {
  
  _impl_.encode_angle_vector_ = value;
}
inline void GroundBox3dCoder::set_encode_angle_vector(bool value) {
  _internal_set_encode_angle_vector(value);
  // @@protoc_insertion_point(field_set:second.protos.GroundBox3dCoder.encode_angle_vector)
}

// -------------------------------------------------------------------

// BevBoxCoder

// bool linear_dim = 1;
inline void BevBoxCoder::clear_linear_dim() {
  _impl_.linear_dim_ = false;
}
inline bool BevBoxCoder::_internal_linear_dim() const {
  return _impl_.linear_dim_;
}
inline bool BevBoxCoder::linear_dim() const {
  // @@protoc_insertion_point(field_get:second.protos.BevBoxCoder.linear_dim)
  return _internal_linear_dim();
}
inline void BevBoxCoder::_internal_set_linear_dim(bool value) {
  
  _impl_.linear_dim_ = value;
}
inline void BevBoxCoder::set_linear_dim(bool value) {
  _internal_set_linear_dim(value);
  // @@protoc_insertion_point(field_set:second.protos.BevBoxCoder.linear_dim)
}

// bool encode_angle_vector = 2;
inline void BevBoxCoder::clear_encode_angle_vector() {
  _impl_.encode_angle_vector_ = false;
}
inline bool BevBoxCoder::_internal_encode_angle_vector() const {
  return _impl_.encode_angle_vector_;
}
inline bool BevBoxCoder::encode_angle_vector() const {
  // @@protoc_insertion_point(field_get:second.protos.BevBoxCoder.encode_angle_vector)
  return _internal_encode_angle_vector();
}
inline void BevBoxCoder::_internal_set_encode_angle_vector(bool value) {
  
  _impl_.encode_angle_vector_ = value;
}
inline void BevBoxCoder::set_encode_angle_vector(bool value) {
  _internal_set_encode_angle_vector(value);
  // @@protoc_insertion_point(field_set:second.protos.BevBoxCoder.encode_angle_vector)
}

// float z_fixed = 3;
inline void BevBoxCoder::clear_z_fixed() {
  _impl_.z_fixed_ = 0;
}
inline float BevBoxCoder::_internal_z_fixed() const {
  return _impl_.z_fixed_;
}
inline float BevBoxCoder::z_fixed() const {
  // @@protoc_insertion_point(field_get:second.protos.BevBoxCoder.z_fixed)
  return _internal_z_fixed();
}
inline void BevBoxCoder::_internal_set_z_fixed(float value) {
  
  _impl_.z_fixed_ = value;
}
inline void BevBoxCoder::set_z_fixed(float value) {
  _internal_set_z_fixed(value);
  // @@protoc_insertion_point(field_set:second.protos.BevBoxCoder.z_fixed)
}

// float h_fixed = 4;
inline void BevBoxCoder::clear_h_fixed() {
  _impl_.h_fixed_ = 0;
}
inline float BevBoxCoder::_internal_h_fixed() const {
  return _impl_.h_fixed_;
}
inline float BevBoxCoder::h_fixed() const {
  // @@protoc_insertion_point(field_get:second.protos.BevBoxCoder.h_fixed)
  return _internal_h_fixed();
}
inline void BevBoxCoder::_internal_set_h_fixed(float value) {
  
  _impl_.h_fixed_ = value;
}
inline void BevBoxCoder::set_h_fixed(float value) {
  _internal_set_h_fixed(value);
  // @@protoc_insertion_point(field_set:second.protos.BevBoxCoder.h_fixed)
}

#ifdef __GNUC__
  #pragma GCC diagnostic pop
#endif  // __GNUC__
// -------------------------------------------------------------------

// -------------------------------------------------------------------


// @@protoc_insertion_point(namespace_scope)

}  // namespace protos
}  // namespace second

// @@protoc_insertion_point(global_scope)

#include <google/protobuf/port_undef.inc>
#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_second_2fprotos_2fbox_5fcoder_2eproto
