File image_to_tensor_calculator.pb.cc
File List > calculators > tensor > image_to_tensor_calculator.pb.cc
Go to the documentation of this file
// Generated by the protocol buffer compiler. DO NOT EDIT!
// source: mediapipe/calculators/tensor/image_to_tensor_calculator.proto
#include "mediapipe/calculators/tensor/image_to_tensor_calculator.pb.h"
#include <algorithm>
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/extension_set.h>
#include <google/protobuf/wire_format_lite.h>
#include <google/protobuf/descriptor.h>
#include <google/protobuf/generated_message_reflection.h>
#include <google/protobuf/reflection_ops.h>
#include <google/protobuf/wire_format.h>
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
PROTOBUF_PRAGMA_INIT_SEG
namespace mediapipe {
constexpr ImageToTensorCalculatorOptions_FloatRange::ImageToTensorCalculatorOptions_FloatRange(
::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
: min_(0)
, max_(0){}
struct ImageToTensorCalculatorOptions_FloatRangeDefaultTypeInternal {
constexpr ImageToTensorCalculatorOptions_FloatRangeDefaultTypeInternal()
: _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
~ImageToTensorCalculatorOptions_FloatRangeDefaultTypeInternal() {}
union {
ImageToTensorCalculatorOptions_FloatRange _instance;
};
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ImageToTensorCalculatorOptions_FloatRangeDefaultTypeInternal _ImageToTensorCalculatorOptions_FloatRange_default_instance_;
constexpr ImageToTensorCalculatorOptions_IntRange::ImageToTensorCalculatorOptions_IntRange(
::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
: min_(int64_t{0})
, max_(int64_t{0}){}
struct ImageToTensorCalculatorOptions_IntRangeDefaultTypeInternal {
constexpr ImageToTensorCalculatorOptions_IntRangeDefaultTypeInternal()
: _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
~ImageToTensorCalculatorOptions_IntRangeDefaultTypeInternal() {}
union {
ImageToTensorCalculatorOptions_IntRange _instance;
};
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ImageToTensorCalculatorOptions_IntRangeDefaultTypeInternal _ImageToTensorCalculatorOptions_IntRange_default_instance_;
constexpr ImageToTensorCalculatorOptions_UIntRange::ImageToTensorCalculatorOptions_UIntRange(
::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
: min_(uint64_t{0u})
, max_(uint64_t{0u}){}
struct ImageToTensorCalculatorOptions_UIntRangeDefaultTypeInternal {
constexpr ImageToTensorCalculatorOptions_UIntRangeDefaultTypeInternal()
: _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
~ImageToTensorCalculatorOptions_UIntRangeDefaultTypeInternal() {}
union {
ImageToTensorCalculatorOptions_UIntRange _instance;
};
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ImageToTensorCalculatorOptions_UIntRangeDefaultTypeInternal _ImageToTensorCalculatorOptions_UIntRange_default_instance_;
constexpr ImageToTensorCalculatorOptions::ImageToTensorCalculatorOptions(
::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
: output_tensor_width_(0)
, output_tensor_height_(0)
, keep_aspect_ratio_(false)
, gpu_origin_(0)
, border_mode_(0)
, _oneof_case_{}{}
struct ImageToTensorCalculatorOptionsDefaultTypeInternal {
constexpr ImageToTensorCalculatorOptionsDefaultTypeInternal()
: _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
~ImageToTensorCalculatorOptionsDefaultTypeInternal() {}
union {
ImageToTensorCalculatorOptions _instance;
};
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ImageToTensorCalculatorOptionsDefaultTypeInternal _ImageToTensorCalculatorOptions_default_instance_;
} // namespace mediapipe
static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_mediapipe_2fcalculators_2ftensor_2fimage_5fto_5ftensor_5fcalculator_2eproto[4];
static const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* file_level_enum_descriptors_mediapipe_2fcalculators_2ftensor_2fimage_5fto_5ftensor_5fcalculator_2eproto[1];
static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_mediapipe_2fcalculators_2ftensor_2fimage_5fto_5ftensor_5fcalculator_2eproto = nullptr;
const uint32_t TableStruct_mediapipe_2fcalculators_2ftensor_2fimage_5fto_5ftensor_5fcalculator_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
PROTOBUF_FIELD_OFFSET(::mediapipe::ImageToTensorCalculatorOptions_FloatRange, _has_bits_),
PROTOBUF_FIELD_OFFSET(::mediapipe::ImageToTensorCalculatorOptions_FloatRange, _internal_metadata_),
~0u, // no _extensions_
~0u, // no _oneof_case_
~0u, // no _weak_field_map_
~0u, // no _inlined_string_donated_
PROTOBUF_FIELD_OFFSET(::mediapipe::ImageToTensorCalculatorOptions_FloatRange, min_),
PROTOBUF_FIELD_OFFSET(::mediapipe::ImageToTensorCalculatorOptions_FloatRange, max_),
0,
1,
PROTOBUF_FIELD_OFFSET(::mediapipe::ImageToTensorCalculatorOptions_IntRange, _has_bits_),
PROTOBUF_FIELD_OFFSET(::mediapipe::ImageToTensorCalculatorOptions_IntRange, _internal_metadata_),
~0u, // no _extensions_
~0u, // no _oneof_case_
~0u, // no _weak_field_map_
~0u, // no _inlined_string_donated_
PROTOBUF_FIELD_OFFSET(::mediapipe::ImageToTensorCalculatorOptions_IntRange, min_),
PROTOBUF_FIELD_OFFSET(::mediapipe::ImageToTensorCalculatorOptions_IntRange, max_),
0,
1,
PROTOBUF_FIELD_OFFSET(::mediapipe::ImageToTensorCalculatorOptions_UIntRange, _has_bits_),
PROTOBUF_FIELD_OFFSET(::mediapipe::ImageToTensorCalculatorOptions_UIntRange, _internal_metadata_),
~0u, // no _extensions_
~0u, // no _oneof_case_
~0u, // no _weak_field_map_
~0u, // no _inlined_string_donated_
PROTOBUF_FIELD_OFFSET(::mediapipe::ImageToTensorCalculatorOptions_UIntRange, min_),
PROTOBUF_FIELD_OFFSET(::mediapipe::ImageToTensorCalculatorOptions_UIntRange, max_),
0,
1,
PROTOBUF_FIELD_OFFSET(::mediapipe::ImageToTensorCalculatorOptions, _has_bits_),
PROTOBUF_FIELD_OFFSET(::mediapipe::ImageToTensorCalculatorOptions, _internal_metadata_),
~0u, // no _extensions_
PROTOBUF_FIELD_OFFSET(::mediapipe::ImageToTensorCalculatorOptions, _oneof_case_[0]),
~0u, // no _weak_field_map_
~0u, // no _inlined_string_donated_
PROTOBUF_FIELD_OFFSET(::mediapipe::ImageToTensorCalculatorOptions, output_tensor_width_),
PROTOBUF_FIELD_OFFSET(::mediapipe::ImageToTensorCalculatorOptions, output_tensor_height_),
PROTOBUF_FIELD_OFFSET(::mediapipe::ImageToTensorCalculatorOptions, keep_aspect_ratio_),
::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
PROTOBUF_FIELD_OFFSET(::mediapipe::ImageToTensorCalculatorOptions, gpu_origin_),
PROTOBUF_FIELD_OFFSET(::mediapipe::ImageToTensorCalculatorOptions, border_mode_),
PROTOBUF_FIELD_OFFSET(::mediapipe::ImageToTensorCalculatorOptions, range_),
0,
1,
2,
~0u,
~0u,
~0u,
3,
4,
};
static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
{ 0, 8, -1, sizeof(::mediapipe::ImageToTensorCalculatorOptions_FloatRange)},
{ 10, 18, -1, sizeof(::mediapipe::ImageToTensorCalculatorOptions_IntRange)},
{ 20, 28, -1, sizeof(::mediapipe::ImageToTensorCalculatorOptions_UIntRange)},
{ 30, 45, -1, sizeof(::mediapipe::ImageToTensorCalculatorOptions)},
};
static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = {
reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::mediapipe::_ImageToTensorCalculatorOptions_FloatRange_default_instance_),
reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::mediapipe::_ImageToTensorCalculatorOptions_IntRange_default_instance_),
reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::mediapipe::_ImageToTensorCalculatorOptions_UIntRange_default_instance_),
reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::mediapipe::_ImageToTensorCalculatorOptions_default_instance_),
};
const char descriptor_table_protodef_mediapipe_2fcalculators_2ftensor_2fimage_5fto_5ftensor_5fcalculator_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) =
"\n=mediapipe/calculators/tensor/image_to_"
"tensor_calculator.proto\022\tmediapipe\032$medi"
"apipe/framework/calculator.proto\032\036mediap"
"ipe/gpu/gpu_origin.proto\"\240\006\n\036ImageToTens"
"orCalculatorOptions\022\033\n\023output_tensor_wid"
"th\030\001 \001(\005\022\034\n\024output_tensor_height\030\002 \001(\005\022\031"
"\n\021keep_aspect_ratio\030\003 \001(\010\022Y\n\031output_tens"
"or_float_range\030\004 \001(\01324.mediapipe.ImageTo"
"TensorCalculatorOptions.FloatRangeH\000\022U\n\027"
"output_tensor_int_range\030\007 \001(\01322.mediapip"
"e.ImageToTensorCalculatorOptions.IntRang"
"eH\000\022W\n\030output_tensor_uint_range\030\010 \001(\01323."
"mediapipe.ImageToTensorCalculatorOptions"
".UIntRangeH\000\022-\n\ngpu_origin\030\005 \001(\0162\031.media"
"pipe.GpuOrigin.Mode\022I\n\013border_mode\030\006 \001(\016"
"24.mediapipe.ImageToTensorCalculatorOpti"
"ons.BorderMode\032&\n\nFloatRange\022\013\n\003min\030\001 \001("
"\002\022\013\n\003max\030\002 \001(\002\032$\n\010IntRange\022\013\n\003min\030\001 \001(\003\022"
"\013\n\003max\030\002 \001(\003\032%\n\tUIntRange\022\013\n\003min\030\001 \001(\004\022\013"
"\n\003max\030\002 \001(\004\"K\n\nBorderMode\022\026\n\022BORDER_UNSP"
"ECIFIED\020\000\022\017\n\013BORDER_ZERO\020\001\022\024\n\020BORDER_REP"
"LICATE\020\0022X\n\003ext\022\034.mediapipe.CalculatorOp"
"tions\030\323\352\267\237\001 \001(\0132).mediapipe.ImageToTenso"
"rCalculatorOptionsB\007\n\005range"
;
static const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable*const descriptor_table_mediapipe_2fcalculators_2ftensor_2fimage_5fto_5ftensor_5fcalculator_2eproto_deps[2] = {
&::descriptor_table_mediapipe_2fframework_2fcalculator_2eproto,
&::descriptor_table_mediapipe_2fgpu_2fgpu_5forigin_2eproto,
};
static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_mediapipe_2fcalculators_2ftensor_2fimage_5fto_5ftensor_5fcalculator_2eproto_once;
const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_mediapipe_2fcalculators_2ftensor_2fimage_5fto_5ftensor_5fcalculator_2eproto = {
false, false, 947, descriptor_table_protodef_mediapipe_2fcalculators_2ftensor_2fimage_5fto_5ftensor_5fcalculator_2eproto, "mediapipe/calculators/tensor/image_to_tensor_calculator.proto",
&descriptor_table_mediapipe_2fcalculators_2ftensor_2fimage_5fto_5ftensor_5fcalculator_2eproto_once, descriptor_table_mediapipe_2fcalculators_2ftensor_2fimage_5fto_5ftensor_5fcalculator_2eproto_deps, 2, 4,
schemas, file_default_instances, TableStruct_mediapipe_2fcalculators_2ftensor_2fimage_5fto_5ftensor_5fcalculator_2eproto::offsets,
file_level_metadata_mediapipe_2fcalculators_2ftensor_2fimage_5fto_5ftensor_5fcalculator_2eproto, file_level_enum_descriptors_mediapipe_2fcalculators_2ftensor_2fimage_5fto_5ftensor_5fcalculator_2eproto, file_level_service_descriptors_mediapipe_2fcalculators_2ftensor_2fimage_5fto_5ftensor_5fcalculator_2eproto,
};
PROTOBUF_ATTRIBUTE_WEAK const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable* descriptor_table_mediapipe_2fcalculators_2ftensor_2fimage_5fto_5ftensor_5fcalculator_2eproto_getter() {
return &descriptor_table_mediapipe_2fcalculators_2ftensor_2fimage_5fto_5ftensor_5fcalculator_2eproto;
}
// Force running AddDescriptors() at dynamic initialization time.
PROTOBUF_ATTRIBUTE_INIT_PRIORITY static ::PROTOBUF_NAMESPACE_ID::internal::AddDescriptorsRunner dynamic_init_dummy_mediapipe_2fcalculators_2ftensor_2fimage_5fto_5ftensor_5fcalculator_2eproto(&descriptor_table_mediapipe_2fcalculators_2ftensor_2fimage_5fto_5ftensor_5fcalculator_2eproto);
namespace mediapipe {
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ImageToTensorCalculatorOptions_BorderMode_descriptor() {
::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_mediapipe_2fcalculators_2ftensor_2fimage_5fto_5ftensor_5fcalculator_2eproto);
return file_level_enum_descriptors_mediapipe_2fcalculators_2ftensor_2fimage_5fto_5ftensor_5fcalculator_2eproto[0];
}
bool ImageToTensorCalculatorOptions_BorderMode_IsValid(int value) {
switch (value) {
case 0:
case 1:
case 2:
return true;
default:
return false;
}
}
#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
constexpr ImageToTensorCalculatorOptions_BorderMode ImageToTensorCalculatorOptions::BORDER_UNSPECIFIED;
constexpr ImageToTensorCalculatorOptions_BorderMode ImageToTensorCalculatorOptions::BORDER_ZERO;
constexpr ImageToTensorCalculatorOptions_BorderMode ImageToTensorCalculatorOptions::BORDER_REPLICATE;
constexpr ImageToTensorCalculatorOptions_BorderMode ImageToTensorCalculatorOptions::BorderMode_MIN;
constexpr ImageToTensorCalculatorOptions_BorderMode ImageToTensorCalculatorOptions::BorderMode_MAX;
constexpr int ImageToTensorCalculatorOptions::BorderMode_ARRAYSIZE;
#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
// ===================================================================
class ImageToTensorCalculatorOptions_FloatRange::_Internal {
public:
using HasBits = decltype(std::declval<ImageToTensorCalculatorOptions_FloatRange>()._has_bits_);
static void set_has_min(HasBits* has_bits) {
(*has_bits)[0] |= 1u;
}
static void set_has_max(HasBits* has_bits) {
(*has_bits)[0] |= 2u;
}
};
ImageToTensorCalculatorOptions_FloatRange::ImageToTensorCalculatorOptions_FloatRange(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned)
: ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
SharedCtor();
if (!is_message_owned) {
RegisterArenaDtor(arena);
}
// @@protoc_insertion_point(arena_constructor:mediapipe.ImageToTensorCalculatorOptions.FloatRange)
}
ImageToTensorCalculatorOptions_FloatRange::ImageToTensorCalculatorOptions_FloatRange(const ImageToTensorCalculatorOptions_FloatRange& from)
: ::PROTOBUF_NAMESPACE_ID::Message(),
_has_bits_(from._has_bits_) {
_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
::memcpy(&min_, &from.min_,
static_cast<size_t>(reinterpret_cast<char*>(&max_) -
reinterpret_cast<char*>(&min_)) + sizeof(max_));
// @@protoc_insertion_point(copy_constructor:mediapipe.ImageToTensorCalculatorOptions.FloatRange)
}
inline void ImageToTensorCalculatorOptions_FloatRange::SharedCtor() {
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
reinterpret_cast<char*>(&min_) - reinterpret_cast<char*>(this)),
0, static_cast<size_t>(reinterpret_cast<char*>(&max_) -
reinterpret_cast<char*>(&min_)) + sizeof(max_));
}
ImageToTensorCalculatorOptions_FloatRange::~ImageToTensorCalculatorOptions_FloatRange() {
// @@protoc_insertion_point(destructor:mediapipe.ImageToTensorCalculatorOptions.FloatRange)
if (GetArenaForAllocation() != nullptr) return;
SharedDtor();
_internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
inline void ImageToTensorCalculatorOptions_FloatRange::SharedDtor() {
GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
}
void ImageToTensorCalculatorOptions_FloatRange::ArenaDtor(void* object) {
ImageToTensorCalculatorOptions_FloatRange* _this = reinterpret_cast< ImageToTensorCalculatorOptions_FloatRange* >(object);
(void)_this;
}
void ImageToTensorCalculatorOptions_FloatRange::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void ImageToTensorCalculatorOptions_FloatRange::SetCachedSize(int size) const {
_cached_size_.Set(size);
}
void ImageToTensorCalculatorOptions_FloatRange::Clear() {
// @@protoc_insertion_point(message_clear_start:mediapipe.ImageToTensorCalculatorOptions.FloatRange)
uint32_t cached_has_bits = 0;
// Prevent compiler warnings about cached_has_bits being unused
(void) cached_has_bits;
cached_has_bits = _has_bits_[0];
if (cached_has_bits & 0x00000003u) {
::memset(&min_, 0, static_cast<size_t>(
reinterpret_cast<char*>(&max_) -
reinterpret_cast<char*>(&min_)) + sizeof(max_));
}
_has_bits_.Clear();
_internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
const char* ImageToTensorCalculatorOptions_FloatRange::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
_Internal::HasBits has_bits{};
while (!ctx->Done(&ptr)) {
uint32_t tag;
ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
switch (tag >> 3) {
// optional float min = 1;
case 1:
if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 13)) {
_Internal::set_has_min(&has_bits);
min_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
ptr += sizeof(float);
} else
goto handle_unusual;
continue;
// optional float max = 2;
case 2:
if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 21)) {
_Internal::set_has_max(&has_bits);
max_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
ptr += sizeof(float);
} else
goto handle_unusual;
continue;
default:
goto handle_unusual;
} // switch
handle_unusual:
if ((tag == 0) || ((tag & 7) == 4)) {
CHK_(ptr);
ctx->SetLastTag(tag);
goto message_done;
}
ptr = UnknownFieldParse(
tag,
_internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
ptr, ctx);
CHK_(ptr != nullptr);
} // while
message_done:
_has_bits_.Or(has_bits);
return ptr;
failure:
ptr = nullptr;
goto message_done;
#undef CHK_
}
uint8_t* ImageToTensorCalculatorOptions_FloatRange::_InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
// @@protoc_insertion_point(serialize_to_array_start:mediapipe.ImageToTensorCalculatorOptions.FloatRange)
uint32_t cached_has_bits = 0;
(void) cached_has_bits;
cached_has_bits = _has_bits_[0];
// optional float min = 1;
if (cached_has_bits & 0x00000001u) {
target = stream->EnsureSpace(target);
target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(1, this->_internal_min(), target);
}
// optional float max = 2;
if (cached_has_bits & 0x00000002u) {
target = stream->EnsureSpace(target);
target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(2, this->_internal_max(), target);
}
if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
_internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
}
// @@protoc_insertion_point(serialize_to_array_end:mediapipe.ImageToTensorCalculatorOptions.FloatRange)
return target;
}
size_t ImageToTensorCalculatorOptions_FloatRange::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:mediapipe.ImageToTensorCalculatorOptions.FloatRange)
size_t total_size = 0;
uint32_t cached_has_bits = 0;
// Prevent compiler warnings about cached_has_bits being unused
(void) cached_has_bits;
cached_has_bits = _has_bits_[0];
if (cached_has_bits & 0x00000003u) {
// optional float min = 1;
if (cached_has_bits & 0x00000001u) {
total_size += 1 + 4;
}
// optional float max = 2;
if (cached_has_bits & 0x00000002u) {
total_size += 1 + 4;
}
}
return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ImageToTensorCalculatorOptions_FloatRange::_class_data_ = {
::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
ImageToTensorCalculatorOptions_FloatRange::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ImageToTensorCalculatorOptions_FloatRange::GetClassData() const { return &_class_data_; }
void ImageToTensorCalculatorOptions_FloatRange::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
const ::PROTOBUF_NAMESPACE_ID::Message& from) {
static_cast<ImageToTensorCalculatorOptions_FloatRange *>(to)->MergeFrom(
static_cast<const ImageToTensorCalculatorOptions_FloatRange &>(from));
}
void ImageToTensorCalculatorOptions_FloatRange::MergeFrom(const ImageToTensorCalculatorOptions_FloatRange& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:mediapipe.ImageToTensorCalculatorOptions.FloatRange)
GOOGLE_DCHECK_NE(&from, this);
uint32_t cached_has_bits = 0;
(void) cached_has_bits;
cached_has_bits = from._has_bits_[0];
if (cached_has_bits & 0x00000003u) {
if (cached_has_bits & 0x00000001u) {
min_ = from.min_;
}
if (cached_has_bits & 0x00000002u) {
max_ = from.max_;
}
_has_bits_[0] |= cached_has_bits;
}
_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}
void ImageToTensorCalculatorOptions_FloatRange::CopyFrom(const ImageToTensorCalculatorOptions_FloatRange& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:mediapipe.ImageToTensorCalculatorOptions.FloatRange)
if (&from == this) return;
Clear();
MergeFrom(from);
}
bool ImageToTensorCalculatorOptions_FloatRange::IsInitialized() const {
return true;
}
void ImageToTensorCalculatorOptions_FloatRange::InternalSwap(ImageToTensorCalculatorOptions_FloatRange* other) {
using std::swap;
_internal_metadata_.InternalSwap(&other->_internal_metadata_);
swap(_has_bits_[0], other->_has_bits_[0]);
::PROTOBUF_NAMESPACE_ID::internal::memswap<
PROTOBUF_FIELD_OFFSET(ImageToTensorCalculatorOptions_FloatRange, max_)
+ sizeof(ImageToTensorCalculatorOptions_FloatRange::max_)
- PROTOBUF_FIELD_OFFSET(ImageToTensorCalculatorOptions_FloatRange, min_)>(
reinterpret_cast<char*>(&min_),
reinterpret_cast<char*>(&other->min_));
}
::PROTOBUF_NAMESPACE_ID::Metadata ImageToTensorCalculatorOptions_FloatRange::GetMetadata() const {
return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
&descriptor_table_mediapipe_2fcalculators_2ftensor_2fimage_5fto_5ftensor_5fcalculator_2eproto_getter, &descriptor_table_mediapipe_2fcalculators_2ftensor_2fimage_5fto_5ftensor_5fcalculator_2eproto_once,
file_level_metadata_mediapipe_2fcalculators_2ftensor_2fimage_5fto_5ftensor_5fcalculator_2eproto[0]);
}
// ===================================================================
class ImageToTensorCalculatorOptions_IntRange::_Internal {
public:
using HasBits = decltype(std::declval<ImageToTensorCalculatorOptions_IntRange>()._has_bits_);
static void set_has_min(HasBits* has_bits) {
(*has_bits)[0] |= 1u;
}
static void set_has_max(HasBits* has_bits) {
(*has_bits)[0] |= 2u;
}
};
ImageToTensorCalculatorOptions_IntRange::ImageToTensorCalculatorOptions_IntRange(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned)
: ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
SharedCtor();
if (!is_message_owned) {
RegisterArenaDtor(arena);
}
// @@protoc_insertion_point(arena_constructor:mediapipe.ImageToTensorCalculatorOptions.IntRange)
}
ImageToTensorCalculatorOptions_IntRange::ImageToTensorCalculatorOptions_IntRange(const ImageToTensorCalculatorOptions_IntRange& from)
: ::PROTOBUF_NAMESPACE_ID::Message(),
_has_bits_(from._has_bits_) {
_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
::memcpy(&min_, &from.min_,
static_cast<size_t>(reinterpret_cast<char*>(&max_) -
reinterpret_cast<char*>(&min_)) + sizeof(max_));
// @@protoc_insertion_point(copy_constructor:mediapipe.ImageToTensorCalculatorOptions.IntRange)
}
inline void ImageToTensorCalculatorOptions_IntRange::SharedCtor() {
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
reinterpret_cast<char*>(&min_) - reinterpret_cast<char*>(this)),
0, static_cast<size_t>(reinterpret_cast<char*>(&max_) -
reinterpret_cast<char*>(&min_)) + sizeof(max_));
}
ImageToTensorCalculatorOptions_IntRange::~ImageToTensorCalculatorOptions_IntRange() {
// @@protoc_insertion_point(destructor:mediapipe.ImageToTensorCalculatorOptions.IntRange)
if (GetArenaForAllocation() != nullptr) return;
SharedDtor();
_internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
inline void ImageToTensorCalculatorOptions_IntRange::SharedDtor() {
GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
}
void ImageToTensorCalculatorOptions_IntRange::ArenaDtor(void* object) {
ImageToTensorCalculatorOptions_IntRange* _this = reinterpret_cast< ImageToTensorCalculatorOptions_IntRange* >(object);
(void)_this;
}
void ImageToTensorCalculatorOptions_IntRange::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void ImageToTensorCalculatorOptions_IntRange::SetCachedSize(int size) const {
_cached_size_.Set(size);
}
void ImageToTensorCalculatorOptions_IntRange::Clear() {
// @@protoc_insertion_point(message_clear_start:mediapipe.ImageToTensorCalculatorOptions.IntRange)
uint32_t cached_has_bits = 0;
// Prevent compiler warnings about cached_has_bits being unused
(void) cached_has_bits;
cached_has_bits = _has_bits_[0];
if (cached_has_bits & 0x00000003u) {
::memset(&min_, 0, static_cast<size_t>(
reinterpret_cast<char*>(&max_) -
reinterpret_cast<char*>(&min_)) + sizeof(max_));
}
_has_bits_.Clear();
_internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
const char* ImageToTensorCalculatorOptions_IntRange::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
_Internal::HasBits has_bits{};
while (!ctx->Done(&ptr)) {
uint32_t tag;
ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
switch (tag >> 3) {
// optional int64 min = 1;
case 1:
if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
_Internal::set_has_min(&has_bits);
min_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
CHK_(ptr);
} else
goto handle_unusual;
continue;
// optional int64 max = 2;
case 2:
if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
_Internal::set_has_max(&has_bits);
max_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
CHK_(ptr);
} else
goto handle_unusual;
continue;
default:
goto handle_unusual;
} // switch
handle_unusual:
if ((tag == 0) || ((tag & 7) == 4)) {
CHK_(ptr);
ctx->SetLastTag(tag);
goto message_done;
}
ptr = UnknownFieldParse(
tag,
_internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
ptr, ctx);
CHK_(ptr != nullptr);
} // while
message_done:
_has_bits_.Or(has_bits);
return ptr;
failure:
ptr = nullptr;
goto message_done;
#undef CHK_
}
uint8_t* ImageToTensorCalculatorOptions_IntRange::_InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
// @@protoc_insertion_point(serialize_to_array_start:mediapipe.ImageToTensorCalculatorOptions.IntRange)
uint32_t cached_has_bits = 0;
(void) cached_has_bits;
cached_has_bits = _has_bits_[0];
// optional int64 min = 1;
if (cached_has_bits & 0x00000001u) {
target = stream->EnsureSpace(target);
target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(1, this->_internal_min(), target);
}
// optional int64 max = 2;
if (cached_has_bits & 0x00000002u) {
target = stream->EnsureSpace(target);
target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(2, this->_internal_max(), target);
}
if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
_internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
}
// @@protoc_insertion_point(serialize_to_array_end:mediapipe.ImageToTensorCalculatorOptions.IntRange)
return target;
}
size_t ImageToTensorCalculatorOptions_IntRange::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:mediapipe.ImageToTensorCalculatorOptions.IntRange)
size_t total_size = 0;
uint32_t cached_has_bits = 0;
// Prevent compiler warnings about cached_has_bits being unused
(void) cached_has_bits;
cached_has_bits = _has_bits_[0];
if (cached_has_bits & 0x00000003u) {
// optional int64 min = 1;
if (cached_has_bits & 0x00000001u) {
total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64SizePlusOne(this->_internal_min());
}
// optional int64 max = 2;
if (cached_has_bits & 0x00000002u) {
total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64SizePlusOne(this->_internal_max());
}
}
return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ImageToTensorCalculatorOptions_IntRange::_class_data_ = {
::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
ImageToTensorCalculatorOptions_IntRange::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ImageToTensorCalculatorOptions_IntRange::GetClassData() const { return &_class_data_; }
void ImageToTensorCalculatorOptions_IntRange::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
const ::PROTOBUF_NAMESPACE_ID::Message& from) {
static_cast<ImageToTensorCalculatorOptions_IntRange *>(to)->MergeFrom(
static_cast<const ImageToTensorCalculatorOptions_IntRange &>(from));
}
void ImageToTensorCalculatorOptions_IntRange::MergeFrom(const ImageToTensorCalculatorOptions_IntRange& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:mediapipe.ImageToTensorCalculatorOptions.IntRange)
GOOGLE_DCHECK_NE(&from, this);
uint32_t cached_has_bits = 0;
(void) cached_has_bits;
cached_has_bits = from._has_bits_[0];
if (cached_has_bits & 0x00000003u) {
if (cached_has_bits & 0x00000001u) {
min_ = from.min_;
}
if (cached_has_bits & 0x00000002u) {
max_ = from.max_;
}
_has_bits_[0] |= cached_has_bits;
}
_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}
void ImageToTensorCalculatorOptions_IntRange::CopyFrom(const ImageToTensorCalculatorOptions_IntRange& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:mediapipe.ImageToTensorCalculatorOptions.IntRange)
if (&from == this) return;
Clear();
MergeFrom(from);
}
bool ImageToTensorCalculatorOptions_IntRange::IsInitialized() const {
return true;
}
void ImageToTensorCalculatorOptions_IntRange::InternalSwap(ImageToTensorCalculatorOptions_IntRange* other) {
using std::swap;
_internal_metadata_.InternalSwap(&other->_internal_metadata_);
swap(_has_bits_[0], other->_has_bits_[0]);
::PROTOBUF_NAMESPACE_ID::internal::memswap<
PROTOBUF_FIELD_OFFSET(ImageToTensorCalculatorOptions_IntRange, max_)
+ sizeof(ImageToTensorCalculatorOptions_IntRange::max_)
- PROTOBUF_FIELD_OFFSET(ImageToTensorCalculatorOptions_IntRange, min_)>(
reinterpret_cast<char*>(&min_),
reinterpret_cast<char*>(&other->min_));
}
::PROTOBUF_NAMESPACE_ID::Metadata ImageToTensorCalculatorOptions_IntRange::GetMetadata() const {
return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
&descriptor_table_mediapipe_2fcalculators_2ftensor_2fimage_5fto_5ftensor_5fcalculator_2eproto_getter, &descriptor_table_mediapipe_2fcalculators_2ftensor_2fimage_5fto_5ftensor_5fcalculator_2eproto_once,
file_level_metadata_mediapipe_2fcalculators_2ftensor_2fimage_5fto_5ftensor_5fcalculator_2eproto[1]);
}
// ===================================================================
class ImageToTensorCalculatorOptions_UIntRange::_Internal {
public:
using HasBits = decltype(std::declval<ImageToTensorCalculatorOptions_UIntRange>()._has_bits_);
static void set_has_min(HasBits* has_bits) {
(*has_bits)[0] |= 1u;
}
static void set_has_max(HasBits* has_bits) {
(*has_bits)[0] |= 2u;
}
};
ImageToTensorCalculatorOptions_UIntRange::ImageToTensorCalculatorOptions_UIntRange(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned)
: ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
SharedCtor();
if (!is_message_owned) {
RegisterArenaDtor(arena);
}
// @@protoc_insertion_point(arena_constructor:mediapipe.ImageToTensorCalculatorOptions.UIntRange)
}
ImageToTensorCalculatorOptions_UIntRange::ImageToTensorCalculatorOptions_UIntRange(const ImageToTensorCalculatorOptions_UIntRange& from)
: ::PROTOBUF_NAMESPACE_ID::Message(),
_has_bits_(from._has_bits_) {
_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
::memcpy(&min_, &from.min_,
static_cast<size_t>(reinterpret_cast<char*>(&max_) -
reinterpret_cast<char*>(&min_)) + sizeof(max_));
// @@protoc_insertion_point(copy_constructor:mediapipe.ImageToTensorCalculatorOptions.UIntRange)
}
inline void ImageToTensorCalculatorOptions_UIntRange::SharedCtor() {
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
reinterpret_cast<char*>(&min_) - reinterpret_cast<char*>(this)),
0, static_cast<size_t>(reinterpret_cast<char*>(&max_) -
reinterpret_cast<char*>(&min_)) + sizeof(max_));
}
ImageToTensorCalculatorOptions_UIntRange::~ImageToTensorCalculatorOptions_UIntRange() {
// @@protoc_insertion_point(destructor:mediapipe.ImageToTensorCalculatorOptions.UIntRange)
if (GetArenaForAllocation() != nullptr) return;
SharedDtor();
_internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
inline void ImageToTensorCalculatorOptions_UIntRange::SharedDtor() {
GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
}
void ImageToTensorCalculatorOptions_UIntRange::ArenaDtor(void* object) {
ImageToTensorCalculatorOptions_UIntRange* _this = reinterpret_cast< ImageToTensorCalculatorOptions_UIntRange* >(object);
(void)_this;
}
void ImageToTensorCalculatorOptions_UIntRange::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void ImageToTensorCalculatorOptions_UIntRange::SetCachedSize(int size) const {
_cached_size_.Set(size);
}
void ImageToTensorCalculatorOptions_UIntRange::Clear() {
// @@protoc_insertion_point(message_clear_start:mediapipe.ImageToTensorCalculatorOptions.UIntRange)
uint32_t cached_has_bits = 0;
// Prevent compiler warnings about cached_has_bits being unused
(void) cached_has_bits;
cached_has_bits = _has_bits_[0];
if (cached_has_bits & 0x00000003u) {
::memset(&min_, 0, static_cast<size_t>(
reinterpret_cast<char*>(&max_) -
reinterpret_cast<char*>(&min_)) + sizeof(max_));
}
_has_bits_.Clear();
_internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
const char* ImageToTensorCalculatorOptions_UIntRange::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
_Internal::HasBits has_bits{};
while (!ctx->Done(&ptr)) {
uint32_t tag;
ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
switch (tag >> 3) {
// optional uint64 min = 1;
case 1:
if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
_Internal::set_has_min(&has_bits);
min_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
CHK_(ptr);
} else
goto handle_unusual;
continue;
// optional uint64 max = 2;
case 2:
if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
_Internal::set_has_max(&has_bits);
max_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
CHK_(ptr);
} else
goto handle_unusual;
continue;
default:
goto handle_unusual;
} // switch
handle_unusual:
if ((tag == 0) || ((tag & 7) == 4)) {
CHK_(ptr);
ctx->SetLastTag(tag);
goto message_done;
}
ptr = UnknownFieldParse(
tag,
_internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
ptr, ctx);
CHK_(ptr != nullptr);
} // while
message_done:
_has_bits_.Or(has_bits);
return ptr;
failure:
ptr = nullptr;
goto message_done;
#undef CHK_
}
uint8_t* ImageToTensorCalculatorOptions_UIntRange::_InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
// @@protoc_insertion_point(serialize_to_array_start:mediapipe.ImageToTensorCalculatorOptions.UIntRange)
uint32_t cached_has_bits = 0;
(void) cached_has_bits;
cached_has_bits = _has_bits_[0];
// optional uint64 min = 1;
if (cached_has_bits & 0x00000001u) {
target = stream->EnsureSpace(target);
target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(1, this->_internal_min(), target);
}
// optional uint64 max = 2;
if (cached_has_bits & 0x00000002u) {
target = stream->EnsureSpace(target);
target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(2, this->_internal_max(), target);
}
if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
_internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
}
// @@protoc_insertion_point(serialize_to_array_end:mediapipe.ImageToTensorCalculatorOptions.UIntRange)
return target;
}
size_t ImageToTensorCalculatorOptions_UIntRange::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:mediapipe.ImageToTensorCalculatorOptions.UIntRange)
size_t total_size = 0;
uint32_t cached_has_bits = 0;
// Prevent compiler warnings about cached_has_bits being unused
(void) cached_has_bits;
cached_has_bits = _has_bits_[0];
if (cached_has_bits & 0x00000003u) {
// optional uint64 min = 1;
if (cached_has_bits & 0x00000001u) {
total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64SizePlusOne(this->_internal_min());
}
// optional uint64 max = 2;
if (cached_has_bits & 0x00000002u) {
total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64SizePlusOne(this->_internal_max());
}
}
return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ImageToTensorCalculatorOptions_UIntRange::_class_data_ = {
::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
ImageToTensorCalculatorOptions_UIntRange::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ImageToTensorCalculatorOptions_UIntRange::GetClassData() const { return &_class_data_; }
void ImageToTensorCalculatorOptions_UIntRange::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
const ::PROTOBUF_NAMESPACE_ID::Message& from) {
static_cast<ImageToTensorCalculatorOptions_UIntRange *>(to)->MergeFrom(
static_cast<const ImageToTensorCalculatorOptions_UIntRange &>(from));
}
void ImageToTensorCalculatorOptions_UIntRange::MergeFrom(const ImageToTensorCalculatorOptions_UIntRange& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:mediapipe.ImageToTensorCalculatorOptions.UIntRange)
GOOGLE_DCHECK_NE(&from, this);
uint32_t cached_has_bits = 0;
(void) cached_has_bits;
cached_has_bits = from._has_bits_[0];
if (cached_has_bits & 0x00000003u) {
if (cached_has_bits & 0x00000001u) {
min_ = from.min_;
}
if (cached_has_bits & 0x00000002u) {
max_ = from.max_;
}
_has_bits_[0] |= cached_has_bits;
}
_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}
void ImageToTensorCalculatorOptions_UIntRange::CopyFrom(const ImageToTensorCalculatorOptions_UIntRange& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:mediapipe.ImageToTensorCalculatorOptions.UIntRange)
if (&from == this) return;
Clear();
MergeFrom(from);
}
bool ImageToTensorCalculatorOptions_UIntRange::IsInitialized() const {
return true;
}
void ImageToTensorCalculatorOptions_UIntRange::InternalSwap(ImageToTensorCalculatorOptions_UIntRange* other) {
using std::swap;
_internal_metadata_.InternalSwap(&other->_internal_metadata_);
swap(_has_bits_[0], other->_has_bits_[0]);
::PROTOBUF_NAMESPACE_ID::internal::memswap<
PROTOBUF_FIELD_OFFSET(ImageToTensorCalculatorOptions_UIntRange, max_)
+ sizeof(ImageToTensorCalculatorOptions_UIntRange::max_)
- PROTOBUF_FIELD_OFFSET(ImageToTensorCalculatorOptions_UIntRange, min_)>(
reinterpret_cast<char*>(&min_),
reinterpret_cast<char*>(&other->min_));
}
::PROTOBUF_NAMESPACE_ID::Metadata ImageToTensorCalculatorOptions_UIntRange::GetMetadata() const {
return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
&descriptor_table_mediapipe_2fcalculators_2ftensor_2fimage_5fto_5ftensor_5fcalculator_2eproto_getter, &descriptor_table_mediapipe_2fcalculators_2ftensor_2fimage_5fto_5ftensor_5fcalculator_2eproto_once,
file_level_metadata_mediapipe_2fcalculators_2ftensor_2fimage_5fto_5ftensor_5fcalculator_2eproto[2]);
}
// ===================================================================
class ImageToTensorCalculatorOptions::_Internal {
public:
using HasBits = decltype(std::declval<ImageToTensorCalculatorOptions>()._has_bits_);
static void set_has_output_tensor_width(HasBits* has_bits) {
(*has_bits)[0] |= 1u;
}
static void set_has_output_tensor_height(HasBits* has_bits) {
(*has_bits)[0] |= 2u;
}
static void set_has_keep_aspect_ratio(HasBits* has_bits) {
(*has_bits)[0] |= 4u;
}
static const ::mediapipe::ImageToTensorCalculatorOptions_FloatRange& output_tensor_float_range(const ImageToTensorCalculatorOptions* msg);
static const ::mediapipe::ImageToTensorCalculatorOptions_IntRange& output_tensor_int_range(const ImageToTensorCalculatorOptions* msg);
static const ::mediapipe::ImageToTensorCalculatorOptions_UIntRange& output_tensor_uint_range(const ImageToTensorCalculatorOptions* msg);
static void set_has_gpu_origin(HasBits* has_bits) {
(*has_bits)[0] |= 8u;
}
static void set_has_border_mode(HasBits* has_bits) {
(*has_bits)[0] |= 16u;
}
};
const ::mediapipe::ImageToTensorCalculatorOptions_FloatRange&
ImageToTensorCalculatorOptions::_Internal::output_tensor_float_range(const ImageToTensorCalculatorOptions* msg) {
return *msg->range_.output_tensor_float_range_;
}
const ::mediapipe::ImageToTensorCalculatorOptions_IntRange&
ImageToTensorCalculatorOptions::_Internal::output_tensor_int_range(const ImageToTensorCalculatorOptions* msg) {
return *msg->range_.output_tensor_int_range_;
}
const ::mediapipe::ImageToTensorCalculatorOptions_UIntRange&
ImageToTensorCalculatorOptions::_Internal::output_tensor_uint_range(const ImageToTensorCalculatorOptions* msg) {
return *msg->range_.output_tensor_uint_range_;
}
void ImageToTensorCalculatorOptions::set_allocated_output_tensor_float_range(::mediapipe::ImageToTensorCalculatorOptions_FloatRange* output_tensor_float_range) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
clear_range();
if (output_tensor_float_range) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::mediapipe::ImageToTensorCalculatorOptions_FloatRange>::GetOwningArena(output_tensor_float_range);
if (message_arena != submessage_arena) {
output_tensor_float_range = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, output_tensor_float_range, submessage_arena);
}
set_has_output_tensor_float_range();
range_.output_tensor_float_range_ = output_tensor_float_range;
}
// @@protoc_insertion_point(field_set_allocated:mediapipe.ImageToTensorCalculatorOptions.output_tensor_float_range)
}
void ImageToTensorCalculatorOptions::set_allocated_output_tensor_int_range(::mediapipe::ImageToTensorCalculatorOptions_IntRange* output_tensor_int_range) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
clear_range();
if (output_tensor_int_range) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::mediapipe::ImageToTensorCalculatorOptions_IntRange>::GetOwningArena(output_tensor_int_range);
if (message_arena != submessage_arena) {
output_tensor_int_range = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, output_tensor_int_range, submessage_arena);
}
set_has_output_tensor_int_range();
range_.output_tensor_int_range_ = output_tensor_int_range;
}
// @@protoc_insertion_point(field_set_allocated:mediapipe.ImageToTensorCalculatorOptions.output_tensor_int_range)
}
void ImageToTensorCalculatorOptions::set_allocated_output_tensor_uint_range(::mediapipe::ImageToTensorCalculatorOptions_UIntRange* output_tensor_uint_range) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
clear_range();
if (output_tensor_uint_range) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::mediapipe::ImageToTensorCalculatorOptions_UIntRange>::GetOwningArena(output_tensor_uint_range);
if (message_arena != submessage_arena) {
output_tensor_uint_range = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, output_tensor_uint_range, submessage_arena);
}
set_has_output_tensor_uint_range();
range_.output_tensor_uint_range_ = output_tensor_uint_range;
}
// @@protoc_insertion_point(field_set_allocated:mediapipe.ImageToTensorCalculatorOptions.output_tensor_uint_range)
}
ImageToTensorCalculatorOptions::ImageToTensorCalculatorOptions(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned)
: ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
SharedCtor();
if (!is_message_owned) {
RegisterArenaDtor(arena);
}
// @@protoc_insertion_point(arena_constructor:mediapipe.ImageToTensorCalculatorOptions)
}
ImageToTensorCalculatorOptions::ImageToTensorCalculatorOptions(const ImageToTensorCalculatorOptions& from)
: ::PROTOBUF_NAMESPACE_ID::Message(),
_has_bits_(from._has_bits_) {
_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
::memcpy(&output_tensor_width_, &from.output_tensor_width_,
static_cast<size_t>(reinterpret_cast<char*>(&border_mode_) -
reinterpret_cast<char*>(&output_tensor_width_)) + sizeof(border_mode_));
clear_has_range();
switch (from.range_case()) {
case kOutputTensorFloatRange: {
_internal_mutable_output_tensor_float_range()->::mediapipe::ImageToTensorCalculatorOptions_FloatRange::MergeFrom(from._internal_output_tensor_float_range());
break;
}
case kOutputTensorIntRange: {
_internal_mutable_output_tensor_int_range()->::mediapipe::ImageToTensorCalculatorOptions_IntRange::MergeFrom(from._internal_output_tensor_int_range());
break;
}
case kOutputTensorUintRange: {
_internal_mutable_output_tensor_uint_range()->::mediapipe::ImageToTensorCalculatorOptions_UIntRange::MergeFrom(from._internal_output_tensor_uint_range());
break;
}
case RANGE_NOT_SET: {
break;
}
}
// @@protoc_insertion_point(copy_constructor:mediapipe.ImageToTensorCalculatorOptions)
}
inline void ImageToTensorCalculatorOptions::SharedCtor() {
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
reinterpret_cast<char*>(&output_tensor_width_) - reinterpret_cast<char*>(this)),
0, static_cast<size_t>(reinterpret_cast<char*>(&border_mode_) -
reinterpret_cast<char*>(&output_tensor_width_)) + sizeof(border_mode_));
clear_has_range();
}
ImageToTensorCalculatorOptions::~ImageToTensorCalculatorOptions() {
// @@protoc_insertion_point(destructor:mediapipe.ImageToTensorCalculatorOptions)
if (GetArenaForAllocation() != nullptr) return;
SharedDtor();
_internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
inline void ImageToTensorCalculatorOptions::SharedDtor() {
GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
if (has_range()) {
clear_range();
}
}
void ImageToTensorCalculatorOptions::ArenaDtor(void* object) {
ImageToTensorCalculatorOptions* _this = reinterpret_cast< ImageToTensorCalculatorOptions* >(object);
(void)_this;
}
void ImageToTensorCalculatorOptions::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void ImageToTensorCalculatorOptions::SetCachedSize(int size) const {
_cached_size_.Set(size);
}
void ImageToTensorCalculatorOptions::clear_range() {
// @@protoc_insertion_point(one_of_clear_start:mediapipe.ImageToTensorCalculatorOptions)
switch (range_case()) {
case kOutputTensorFloatRange: {
if (GetArenaForAllocation() == nullptr) {
delete range_.output_tensor_float_range_;
}
break;
}
case kOutputTensorIntRange: {
if (GetArenaForAllocation() == nullptr) {
delete range_.output_tensor_int_range_;
}
break;
}
case kOutputTensorUintRange: {
if (GetArenaForAllocation() == nullptr) {
delete range_.output_tensor_uint_range_;
}
break;
}
case RANGE_NOT_SET: {
break;
}
}
_oneof_case_[0] = RANGE_NOT_SET;
}
void ImageToTensorCalculatorOptions::Clear() {
// @@protoc_insertion_point(message_clear_start:mediapipe.ImageToTensorCalculatorOptions)
uint32_t cached_has_bits = 0;
// Prevent compiler warnings about cached_has_bits being unused
(void) cached_has_bits;
cached_has_bits = _has_bits_[0];
if (cached_has_bits & 0x0000001fu) {
::memset(&output_tensor_width_, 0, static_cast<size_t>(
reinterpret_cast<char*>(&border_mode_) -
reinterpret_cast<char*>(&output_tensor_width_)) + sizeof(border_mode_));
}
clear_range();
_has_bits_.Clear();
_internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
const char* ImageToTensorCalculatorOptions::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
_Internal::HasBits has_bits{};
while (!ctx->Done(&ptr)) {
uint32_t tag;
ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
switch (tag >> 3) {
// optional int32 output_tensor_width = 1;
case 1:
if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
_Internal::set_has_output_tensor_width(&has_bits);
output_tensor_width_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
CHK_(ptr);
} else
goto handle_unusual;
continue;
// optional int32 output_tensor_height = 2;
case 2:
if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
_Internal::set_has_output_tensor_height(&has_bits);
output_tensor_height_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
CHK_(ptr);
} else
goto handle_unusual;
continue;
// optional bool keep_aspect_ratio = 3;
case 3:
if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 24)) {
_Internal::set_has_keep_aspect_ratio(&has_bits);
keep_aspect_ratio_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
CHK_(ptr);
} else
goto handle_unusual;
continue;
// .mediapipe.ImageToTensorCalculatorOptions.FloatRange output_tensor_float_range = 4;
case 4:
if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) {
ptr = ctx->ParseMessage(_internal_mutable_output_tensor_float_range(), ptr);
CHK_(ptr);
} else
goto handle_unusual;
continue;
// optional .mediapipe.GpuOrigin.Mode gpu_origin = 5;
case 5:
if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 40)) {
uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
CHK_(ptr);
if (PROTOBUF_PREDICT_TRUE(::mediapipe::GpuOrigin_Mode_IsValid(val))) {
_internal_set_gpu_origin(static_cast<::mediapipe::GpuOrigin_Mode>(val));
} else {
::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(5, val, mutable_unknown_fields());
}
} else
goto handle_unusual;
continue;
// optional .mediapipe.ImageToTensorCalculatorOptions.BorderMode border_mode = 6;
case 6:
if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 48)) {
uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
CHK_(ptr);
if (PROTOBUF_PREDICT_TRUE(::mediapipe::ImageToTensorCalculatorOptions_BorderMode_IsValid(val))) {
_internal_set_border_mode(static_cast<::mediapipe::ImageToTensorCalculatorOptions_BorderMode>(val));
} else {
::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(6, val, mutable_unknown_fields());
}
} else
goto handle_unusual;
continue;
// .mediapipe.ImageToTensorCalculatorOptions.IntRange output_tensor_int_range = 7;
case 7:
if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 58)) {
ptr = ctx->ParseMessage(_internal_mutable_output_tensor_int_range(), ptr);
CHK_(ptr);
} else
goto handle_unusual;
continue;
// .mediapipe.ImageToTensorCalculatorOptions.UIntRange output_tensor_uint_range = 8;
case 8:
if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 66)) {
ptr = ctx->ParseMessage(_internal_mutable_output_tensor_uint_range(), ptr);
CHK_(ptr);
} else
goto handle_unusual;
continue;
default:
goto handle_unusual;
} // switch
handle_unusual:
if ((tag == 0) || ((tag & 7) == 4)) {
CHK_(ptr);
ctx->SetLastTag(tag);
goto message_done;
}
ptr = UnknownFieldParse(
tag,
_internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
ptr, ctx);
CHK_(ptr != nullptr);
} // while
message_done:
_has_bits_.Or(has_bits);
return ptr;
failure:
ptr = nullptr;
goto message_done;
#undef CHK_
}
uint8_t* ImageToTensorCalculatorOptions::_InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
// @@protoc_insertion_point(serialize_to_array_start:mediapipe.ImageToTensorCalculatorOptions)
uint32_t cached_has_bits = 0;
(void) cached_has_bits;
cached_has_bits = _has_bits_[0];
// optional int32 output_tensor_width = 1;
if (cached_has_bits & 0x00000001u) {
target = stream->EnsureSpace(target);
target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_output_tensor_width(), target);
}
// optional int32 output_tensor_height = 2;
if (cached_has_bits & 0x00000002u) {
target = stream->EnsureSpace(target);
target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_output_tensor_height(), target);
}
// optional bool keep_aspect_ratio = 3;
if (cached_has_bits & 0x00000004u) {
target = stream->EnsureSpace(target);
target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(3, this->_internal_keep_aspect_ratio(), target);
}
// .mediapipe.ImageToTensorCalculatorOptions.FloatRange output_tensor_float_range = 4;
if (_internal_has_output_tensor_float_range()) {
target = stream->EnsureSpace(target);
target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
InternalWriteMessage(
4, _Internal::output_tensor_float_range(this), target, stream);
}
// optional .mediapipe.GpuOrigin.Mode gpu_origin = 5;
if (cached_has_bits & 0x00000008u) {
target = stream->EnsureSpace(target);
target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
5, this->_internal_gpu_origin(), target);
}
// optional .mediapipe.ImageToTensorCalculatorOptions.BorderMode border_mode = 6;
if (cached_has_bits & 0x00000010u) {
target = stream->EnsureSpace(target);
target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
6, this->_internal_border_mode(), target);
}
switch (range_case()) {
case kOutputTensorIntRange: {
target = stream->EnsureSpace(target);
target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
InternalWriteMessage(
7, _Internal::output_tensor_int_range(this), target, stream);
break;
}
case kOutputTensorUintRange: {
target = stream->EnsureSpace(target);
target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
InternalWriteMessage(
8, _Internal::output_tensor_uint_range(this), target, stream);
break;
}
default: ;
}
if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
_internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
}
// @@protoc_insertion_point(serialize_to_array_end:mediapipe.ImageToTensorCalculatorOptions)
return target;
}
size_t ImageToTensorCalculatorOptions::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:mediapipe.ImageToTensorCalculatorOptions)
size_t total_size = 0;
uint32_t cached_has_bits = 0;
// Prevent compiler warnings about cached_has_bits being unused
(void) cached_has_bits;
cached_has_bits = _has_bits_[0];
if (cached_has_bits & 0x0000001fu) {
// optional int32 output_tensor_width = 1;
if (cached_has_bits & 0x00000001u) {
total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_output_tensor_width());
}
// optional int32 output_tensor_height = 2;
if (cached_has_bits & 0x00000002u) {
total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_output_tensor_height());
}
// optional bool keep_aspect_ratio = 3;
if (cached_has_bits & 0x00000004u) {
total_size += 1 + 1;
}
// optional .mediapipe.GpuOrigin.Mode gpu_origin = 5;
if (cached_has_bits & 0x00000008u) {
total_size += 1 +
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_gpu_origin());
}
// optional .mediapipe.ImageToTensorCalculatorOptions.BorderMode border_mode = 6;
if (cached_has_bits & 0x00000010u) {
total_size += 1 +
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_border_mode());
}
}
switch (range_case()) {
// .mediapipe.ImageToTensorCalculatorOptions.FloatRange output_tensor_float_range = 4;
case kOutputTensorFloatRange: {
total_size += 1 +
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
*range_.output_tensor_float_range_);
break;
}
// .mediapipe.ImageToTensorCalculatorOptions.IntRange output_tensor_int_range = 7;
case kOutputTensorIntRange: {
total_size += 1 +
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
*range_.output_tensor_int_range_);
break;
}
// .mediapipe.ImageToTensorCalculatorOptions.UIntRange output_tensor_uint_range = 8;
case kOutputTensorUintRange: {
total_size += 1 +
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
*range_.output_tensor_uint_range_);
break;
}
case RANGE_NOT_SET: {
break;
}
}
return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ImageToTensorCalculatorOptions::_class_data_ = {
::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
ImageToTensorCalculatorOptions::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ImageToTensorCalculatorOptions::GetClassData() const { return &_class_data_; }
void ImageToTensorCalculatorOptions::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
const ::PROTOBUF_NAMESPACE_ID::Message& from) {
static_cast<ImageToTensorCalculatorOptions *>(to)->MergeFrom(
static_cast<const ImageToTensorCalculatorOptions &>(from));
}
void ImageToTensorCalculatorOptions::MergeFrom(const ImageToTensorCalculatorOptions& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:mediapipe.ImageToTensorCalculatorOptions)
GOOGLE_DCHECK_NE(&from, this);
uint32_t cached_has_bits = 0;
(void) cached_has_bits;
cached_has_bits = from._has_bits_[0];
if (cached_has_bits & 0x0000001fu) {
if (cached_has_bits & 0x00000001u) {
output_tensor_width_ = from.output_tensor_width_;
}
if (cached_has_bits & 0x00000002u) {
output_tensor_height_ = from.output_tensor_height_;
}
if (cached_has_bits & 0x00000004u) {
keep_aspect_ratio_ = from.keep_aspect_ratio_;
}
if (cached_has_bits & 0x00000008u) {
gpu_origin_ = from.gpu_origin_;
}
if (cached_has_bits & 0x00000010u) {
border_mode_ = from.border_mode_;
}
_has_bits_[0] |= cached_has_bits;
}
switch (from.range_case()) {
case kOutputTensorFloatRange: {
_internal_mutable_output_tensor_float_range()->::mediapipe::ImageToTensorCalculatorOptions_FloatRange::MergeFrom(from._internal_output_tensor_float_range());
break;
}
case kOutputTensorIntRange: {
_internal_mutable_output_tensor_int_range()->::mediapipe::ImageToTensorCalculatorOptions_IntRange::MergeFrom(from._internal_output_tensor_int_range());
break;
}
case kOutputTensorUintRange: {
_internal_mutable_output_tensor_uint_range()->::mediapipe::ImageToTensorCalculatorOptions_UIntRange::MergeFrom(from._internal_output_tensor_uint_range());
break;
}
case RANGE_NOT_SET: {
break;
}
}
_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}
void ImageToTensorCalculatorOptions::CopyFrom(const ImageToTensorCalculatorOptions& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:mediapipe.ImageToTensorCalculatorOptions)
if (&from == this) return;
Clear();
MergeFrom(from);
}
bool ImageToTensorCalculatorOptions::IsInitialized() const {
return true;
}
void ImageToTensorCalculatorOptions::InternalSwap(ImageToTensorCalculatorOptions* other) {
using std::swap;
_internal_metadata_.InternalSwap(&other->_internal_metadata_);
swap(_has_bits_[0], other->_has_bits_[0]);
::PROTOBUF_NAMESPACE_ID::internal::memswap<
PROTOBUF_FIELD_OFFSET(ImageToTensorCalculatorOptions, border_mode_)
+ sizeof(ImageToTensorCalculatorOptions::border_mode_)
- PROTOBUF_FIELD_OFFSET(ImageToTensorCalculatorOptions, output_tensor_width_)>(
reinterpret_cast<char*>(&output_tensor_width_),
reinterpret_cast<char*>(&other->output_tensor_width_));
swap(range_, other->range_);
swap(_oneof_case_[0], other->_oneof_case_[0]);
}
::PROTOBUF_NAMESPACE_ID::Metadata ImageToTensorCalculatorOptions::GetMetadata() const {
return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
&descriptor_table_mediapipe_2fcalculators_2ftensor_2fimage_5fto_5ftensor_5fcalculator_2eproto_getter, &descriptor_table_mediapipe_2fcalculators_2ftensor_2fimage_5fto_5ftensor_5fcalculator_2eproto_once,
file_level_metadata_mediapipe_2fcalculators_2ftensor_2fimage_5fto_5ftensor_5fcalculator_2eproto[3]);
}
#if !defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)
const int ImageToTensorCalculatorOptions::kExtFieldNumber;
#endif
PROTOBUF_ATTRIBUTE_INIT_PRIORITY ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier< ::mediapipe::CalculatorOptions,
::PROTOBUF_NAMESPACE_ID::internal::MessageTypeTraits< ::mediapipe::ImageToTensorCalculatorOptions >, 11, false >
ImageToTensorCalculatorOptions::ext(kExtFieldNumber, ::mediapipe::ImageToTensorCalculatorOptions::default_instance());
// @@protoc_insertion_point(namespace_scope)
} // namespace mediapipe
PROTOBUF_NAMESPACE_OPEN
template<> PROTOBUF_NOINLINE ::mediapipe::ImageToTensorCalculatorOptions_FloatRange* Arena::CreateMaybeMessage< ::mediapipe::ImageToTensorCalculatorOptions_FloatRange >(Arena* arena) {
return Arena::CreateMessageInternal< ::mediapipe::ImageToTensorCalculatorOptions_FloatRange >(arena);
}
template<> PROTOBUF_NOINLINE ::mediapipe::ImageToTensorCalculatorOptions_IntRange* Arena::CreateMaybeMessage< ::mediapipe::ImageToTensorCalculatorOptions_IntRange >(Arena* arena) {
return Arena::CreateMessageInternal< ::mediapipe::ImageToTensorCalculatorOptions_IntRange >(arena);
}
template<> PROTOBUF_NOINLINE ::mediapipe::ImageToTensorCalculatorOptions_UIntRange* Arena::CreateMaybeMessage< ::mediapipe::ImageToTensorCalculatorOptions_UIntRange >(Arena* arena) {
return Arena::CreateMessageInternal< ::mediapipe::ImageToTensorCalculatorOptions_UIntRange >(arena);
}
template<> PROTOBUF_NOINLINE ::mediapipe::ImageToTensorCalculatorOptions* Arena::CreateMaybeMessage< ::mediapipe::ImageToTensorCalculatorOptions >(Arena* arena) {
return Arena::CreateMessageInternal< ::mediapipe::ImageToTensorCalculatorOptions >(arena);
}
PROTOBUF_NAMESPACE_CLOSE
// @@protoc_insertion_point(global_scope)
#include <google/protobuf/port_undef.inc>