mirror of
https://github.com/opencv/opencv.git
synced 2024-12-02 16:00:17 +08:00
1597 lines
58 KiB
C++
1597 lines
58 KiB
C++
// Generated by the protocol buffer compiler. DO NOT EDIT!
|
|
// source: tensor.proto
|
|
|
|
#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION
|
|
#include "tensor.pb.h"
|
|
|
|
#include <algorithm>
|
|
|
|
#include <google/protobuf/stubs/common.h>
|
|
#include <google/protobuf/stubs/port.h>
|
|
#include <google/protobuf/stubs/once.h>
|
|
#include <google/protobuf/io/coded_stream.h>
|
|
#include <google/protobuf/wire_format_lite_inl.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)
|
|
|
|
namespace tensorflow {
|
|
|
|
namespace {
|
|
|
|
const ::google::protobuf::Descriptor* TensorProto_descriptor_ = NULL;
|
|
const ::google::protobuf::internal::GeneratedMessageReflection*
|
|
TensorProto_reflection_ = NULL;
|
|
|
|
} // namespace
|
|
|
|
|
|
void protobuf_AssignDesc_tensor_2eproto() GOOGLE_ATTRIBUTE_COLD;
|
|
void protobuf_AssignDesc_tensor_2eproto() {
|
|
protobuf_AddDesc_tensor_2eproto();
|
|
const ::google::protobuf::FileDescriptor* file =
|
|
::google::protobuf::DescriptorPool::generated_pool()->FindFileByName(
|
|
"tensor.proto");
|
|
GOOGLE_CHECK(file != NULL);
|
|
TensorProto_descriptor_ = file->message_type(0);
|
|
static const int TensorProto_offsets_[13] = {
|
|
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(TensorProto, dtype_),
|
|
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(TensorProto, tensor_shape_),
|
|
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(TensorProto, version_number_),
|
|
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(TensorProto, tensor_content_),
|
|
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(TensorProto, half_val_),
|
|
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(TensorProto, float_val_),
|
|
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(TensorProto, double_val_),
|
|
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(TensorProto, int_val_),
|
|
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(TensorProto, string_val_),
|
|
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(TensorProto, scomplex_val_),
|
|
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(TensorProto, int64_val_),
|
|
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(TensorProto, bool_val_),
|
|
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(TensorProto, dcomplex_val_),
|
|
};
|
|
TensorProto_reflection_ =
|
|
::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection(
|
|
TensorProto_descriptor_,
|
|
TensorProto::internal_default_instance(),
|
|
TensorProto_offsets_,
|
|
-1,
|
|
-1,
|
|
-1,
|
|
sizeof(TensorProto),
|
|
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(TensorProto, _internal_metadata_));
|
|
}
|
|
|
|
namespace {
|
|
|
|
GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_);
|
|
void protobuf_AssignDescriptorsOnce() {
|
|
::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_,
|
|
&protobuf_AssignDesc_tensor_2eproto);
|
|
}
|
|
|
|
void protobuf_RegisterTypes(const ::std::string&) GOOGLE_ATTRIBUTE_COLD;
|
|
void protobuf_RegisterTypes(const ::std::string&) {
|
|
protobuf_AssignDescriptorsOnce();
|
|
::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
|
|
TensorProto_descriptor_, TensorProto::internal_default_instance());
|
|
}
|
|
|
|
} // namespace
|
|
|
|
void protobuf_ShutdownFile_tensor_2eproto() {
|
|
TensorProto_default_instance_.Shutdown();
|
|
delete TensorProto_reflection_;
|
|
}
|
|
|
|
void protobuf_InitDefaults_tensor_2eproto_impl() {
|
|
GOOGLE_PROTOBUF_VERIFY_VERSION;
|
|
|
|
::tensorflow::protobuf_InitDefaults_tensor_5fshape_2eproto();
|
|
::tensorflow::protobuf_InitDefaults_types_2eproto();
|
|
::google::protobuf::internal::GetEmptyString();
|
|
TensorProto_default_instance_.DefaultConstruct();
|
|
TensorProto_default_instance_.get_mutable()->InitAsDefaultInstance();
|
|
}
|
|
|
|
GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_InitDefaults_tensor_2eproto_once_);
|
|
void protobuf_InitDefaults_tensor_2eproto() {
|
|
::google::protobuf::GoogleOnceInit(&protobuf_InitDefaults_tensor_2eproto_once_,
|
|
&protobuf_InitDefaults_tensor_2eproto_impl);
|
|
}
|
|
void protobuf_AddDesc_tensor_2eproto_impl() {
|
|
GOOGLE_PROTOBUF_VERIFY_VERSION;
|
|
|
|
protobuf_InitDefaults_tensor_2eproto();
|
|
::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
|
|
"\n\014tensor.proto\022\ntensorflow\032\022tensor_shape"
|
|
".proto\032\013types.proto\"\345\002\n\013TensorProto\022#\n\005d"
|
|
"type\030\001 \001(\0162\024.tensorflow.DataType\0222\n\014tens"
|
|
"or_shape\030\002 \001(\0132\034.tensorflow.TensorShapeP"
|
|
"roto\022\026\n\016version_number\030\003 \001(\005\022\026\n\016tensor_c"
|
|
"ontent\030\004 \001(\014\022\024\n\010half_val\030\r \003(\005B\002\020\001\022\025\n\tfl"
|
|
"oat_val\030\005 \003(\002B\002\020\001\022\026\n\ndouble_val\030\006 \003(\001B\002\020"
|
|
"\001\022\023\n\007int_val\030\007 \003(\005B\002\020\001\022\022\n\nstring_val\030\010 \003"
|
|
"(\014\022\030\n\014scomplex_val\030\t \003(\002B\002\020\001\022\025\n\tint64_va"
|
|
"l\030\n \003(\003B\002\020\001\022\024\n\010bool_val\030\013 \003(\010B\002\020\001\022\030\n\014dco"
|
|
"mplex_val\030\014 \003(\001B\002\020\001B-\n\030org.tensorflow.fr"
|
|
"ameworkB\014TensorProtosP\001\370\001\001b\006proto3", 474);
|
|
::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
|
|
"tensor.proto", &protobuf_RegisterTypes);
|
|
::tensorflow::protobuf_AddDesc_tensor_5fshape_2eproto();
|
|
::tensorflow::protobuf_AddDesc_types_2eproto();
|
|
::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_tensor_2eproto);
|
|
}
|
|
|
|
GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AddDesc_tensor_2eproto_once_);
|
|
void protobuf_AddDesc_tensor_2eproto() {
|
|
::google::protobuf::GoogleOnceInit(&protobuf_AddDesc_tensor_2eproto_once_,
|
|
&protobuf_AddDesc_tensor_2eproto_impl);
|
|
}
|
|
// Force AddDescriptors() to be called at static initialization time.
|
|
struct StaticDescriptorInitializer_tensor_2eproto {
|
|
StaticDescriptorInitializer_tensor_2eproto() {
|
|
protobuf_AddDesc_tensor_2eproto();
|
|
}
|
|
} static_descriptor_initializer_tensor_2eproto_;
|
|
|
|
namespace {
|
|
|
|
static void MergeFromFail(int line) GOOGLE_ATTRIBUTE_COLD GOOGLE_ATTRIBUTE_NORETURN;
|
|
static void MergeFromFail(int line) {
|
|
::google::protobuf::internal::MergeFromFail(__FILE__, line);
|
|
}
|
|
|
|
} // namespace
|
|
|
|
|
|
// ===================================================================
|
|
|
|
void TensorProto::_slow_mutable_tensor_shape() {
|
|
tensor_shape_ = ::google::protobuf::Arena::CreateMessage< ::tensorflow::TensorShapeProto >(
|
|
GetArenaNoVirtual());
|
|
}
|
|
::tensorflow::TensorShapeProto* TensorProto::_slow_release_tensor_shape() {
|
|
if (tensor_shape_ == NULL) {
|
|
return NULL;
|
|
} else {
|
|
::tensorflow::TensorShapeProto* temp = new ::tensorflow::TensorShapeProto(*tensor_shape_);
|
|
tensor_shape_ = NULL;
|
|
return temp;
|
|
}
|
|
}
|
|
::tensorflow::TensorShapeProto* TensorProto::unsafe_arena_release_tensor_shape() {
|
|
// @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.TensorProto.tensor_shape)
|
|
|
|
::tensorflow::TensorShapeProto* temp = tensor_shape_;
|
|
tensor_shape_ = NULL;
|
|
return temp;
|
|
}
|
|
void TensorProto::_slow_set_allocated_tensor_shape(
|
|
::google::protobuf::Arena* message_arena, ::tensorflow::TensorShapeProto** tensor_shape) {
|
|
if (message_arena != NULL &&
|
|
::google::protobuf::Arena::GetArena(*tensor_shape) == NULL) {
|
|
message_arena->Own(*tensor_shape);
|
|
} else if (message_arena !=
|
|
::google::protobuf::Arena::GetArena(*tensor_shape)) {
|
|
::tensorflow::TensorShapeProto* new_tensor_shape =
|
|
::google::protobuf::Arena::CreateMessage< ::tensorflow::TensorShapeProto >(
|
|
message_arena);
|
|
new_tensor_shape->CopyFrom(**tensor_shape);
|
|
*tensor_shape = new_tensor_shape;
|
|
}
|
|
}
|
|
void TensorProto::unsafe_arena_set_allocated_tensor_shape(
|
|
::tensorflow::TensorShapeProto* tensor_shape) {
|
|
if (GetArenaNoVirtual() == NULL) {
|
|
delete tensor_shape_;
|
|
}
|
|
tensor_shape_ = tensor_shape;
|
|
if (tensor_shape) {
|
|
|
|
} else {
|
|
|
|
}
|
|
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.TensorProto.tensor_shape)
|
|
}
|
|
#if !defined(_MSC_VER) || _MSC_VER >= 1900
|
|
const int TensorProto::kDtypeFieldNumber;
|
|
const int TensorProto::kTensorShapeFieldNumber;
|
|
const int TensorProto::kVersionNumberFieldNumber;
|
|
const int TensorProto::kTensorContentFieldNumber;
|
|
const int TensorProto::kHalfValFieldNumber;
|
|
const int TensorProto::kFloatValFieldNumber;
|
|
const int TensorProto::kDoubleValFieldNumber;
|
|
const int TensorProto::kIntValFieldNumber;
|
|
const int TensorProto::kStringValFieldNumber;
|
|
const int TensorProto::kScomplexValFieldNumber;
|
|
const int TensorProto::kInt64ValFieldNumber;
|
|
const int TensorProto::kBoolValFieldNumber;
|
|
const int TensorProto::kDcomplexValFieldNumber;
|
|
#endif // !defined(_MSC_VER) || _MSC_VER >= 1900
|
|
|
|
TensorProto::TensorProto()
|
|
: ::google::protobuf::Message(), _internal_metadata_(NULL) {
|
|
if (this != internal_default_instance()) protobuf_InitDefaults_tensor_2eproto();
|
|
SharedCtor();
|
|
// @@protoc_insertion_point(constructor:tensorflow.TensorProto)
|
|
}
|
|
TensorProto::TensorProto(::google::protobuf::Arena* arena)
|
|
: ::google::protobuf::Message(),
|
|
_internal_metadata_(arena),
|
|
half_val_(arena),
|
|
float_val_(arena),
|
|
double_val_(arena),
|
|
int_val_(arena),
|
|
string_val_(arena),
|
|
scomplex_val_(arena),
|
|
int64_val_(arena),
|
|
bool_val_(arena),
|
|
dcomplex_val_(arena) {
|
|
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
|
|
protobuf_InitDefaults_tensor_2eproto();
|
|
#endif // GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
|
|
SharedCtor();
|
|
RegisterArenaDtor(arena);
|
|
// @@protoc_insertion_point(arena_constructor:tensorflow.TensorProto)
|
|
}
|
|
|
|
void TensorProto::InitAsDefaultInstance() {
|
|
tensor_shape_ = const_cast< ::tensorflow::TensorShapeProto*>(
|
|
::tensorflow::TensorShapeProto::internal_default_instance());
|
|
}
|
|
|
|
TensorProto::TensorProto(const TensorProto& from)
|
|
: ::google::protobuf::Message(),
|
|
_internal_metadata_(NULL) {
|
|
SharedCtor();
|
|
UnsafeMergeFrom(from);
|
|
// @@protoc_insertion_point(copy_constructor:tensorflow.TensorProto)
|
|
}
|
|
|
|
void TensorProto::SharedCtor() {
|
|
tensor_content_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
|
|
tensor_shape_ = NULL;
|
|
::memset(&dtype_, 0, reinterpret_cast<char*>(&version_number_) -
|
|
reinterpret_cast<char*>(&dtype_) + sizeof(version_number_));
|
|
_cached_size_ = 0;
|
|
}
|
|
|
|
TensorProto::~TensorProto() {
|
|
// @@protoc_insertion_point(destructor:tensorflow.TensorProto)
|
|
SharedDtor();
|
|
}
|
|
|
|
void TensorProto::SharedDtor() {
|
|
::google::protobuf::Arena* arena = GetArenaNoVirtual();
|
|
if (arena != NULL) {
|
|
return;
|
|
}
|
|
|
|
tensor_content_.Destroy(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), arena);
|
|
if (this != &TensorProto_default_instance_.get()) {
|
|
delete tensor_shape_;
|
|
}
|
|
}
|
|
|
|
void TensorProto::ArenaDtor(void* object) {
|
|
TensorProto* _this = reinterpret_cast< TensorProto* >(object);
|
|
(void)_this;
|
|
}
|
|
void TensorProto::RegisterArenaDtor(::google::protobuf::Arena* arena) {
|
|
}
|
|
void TensorProto::SetCachedSize(int size) const {
|
|
GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
|
|
_cached_size_ = size;
|
|
GOOGLE_SAFE_CONCURRENT_WRITES_END();
|
|
}
|
|
const ::google::protobuf::Descriptor* TensorProto::descriptor() {
|
|
protobuf_AssignDescriptorsOnce();
|
|
return TensorProto_descriptor_;
|
|
}
|
|
|
|
const TensorProto& TensorProto::default_instance() {
|
|
protobuf_InitDefaults_tensor_2eproto();
|
|
return *internal_default_instance();
|
|
}
|
|
|
|
::google::protobuf::internal::ExplicitlyConstructed<TensorProto> TensorProto_default_instance_;
|
|
|
|
TensorProto* TensorProto::New(::google::protobuf::Arena* arena) const {
|
|
return ::google::protobuf::Arena::CreateMessage<TensorProto>(arena);
|
|
}
|
|
|
|
void TensorProto::Clear() {
|
|
// @@protoc_insertion_point(message_clear_start:tensorflow.TensorProto)
|
|
#if defined(__clang__)
|
|
#define ZR_HELPER_(f) \
|
|
_Pragma("clang diagnostic push") \
|
|
_Pragma("clang diagnostic ignored \"-Winvalid-offsetof\"") \
|
|
__builtin_offsetof(TensorProto, f) \
|
|
_Pragma("clang diagnostic pop")
|
|
#else
|
|
#define ZR_HELPER_(f) reinterpret_cast<char*>(\
|
|
&reinterpret_cast<TensorProto*>(16)->f)
|
|
#endif
|
|
|
|
#define ZR_(first, last) do {\
|
|
::memset(&(first), 0,\
|
|
ZR_HELPER_(last) - ZR_HELPER_(first) + sizeof(last));\
|
|
} while (0)
|
|
|
|
ZR_(dtype_, version_number_);
|
|
if (GetArenaNoVirtual() == NULL && tensor_shape_ != NULL) delete tensor_shape_;
|
|
tensor_shape_ = NULL;
|
|
tensor_content_.ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
|
|
|
|
#undef ZR_HELPER_
|
|
#undef ZR_
|
|
|
|
half_val_.Clear();
|
|
float_val_.Clear();
|
|
double_val_.Clear();
|
|
int_val_.Clear();
|
|
string_val_.Clear();
|
|
scomplex_val_.Clear();
|
|
int64_val_.Clear();
|
|
bool_val_.Clear();
|
|
dcomplex_val_.Clear();
|
|
}
|
|
|
|
bool TensorProto::MergePartialFromCodedStream(
|
|
::google::protobuf::io::CodedInputStream* input) {
|
|
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
|
|
::google::protobuf::uint32 tag;
|
|
// @@protoc_insertion_point(parse_start:tensorflow.TensorProto)
|
|
for (;;) {
|
|
::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
|
|
tag = p.first;
|
|
if (!p.second) goto handle_unusual;
|
|
switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
|
|
// optional .tensorflow.DataType dtype = 1;
|
|
case 1: {
|
|
if (tag == 8) {
|
|
int value;
|
|
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
|
|
int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
|
|
input, &value)));
|
|
set_dtype(static_cast< ::tensorflow::DataType >(value));
|
|
} else {
|
|
goto handle_unusual;
|
|
}
|
|
if (input->ExpectTag(18)) goto parse_tensor_shape;
|
|
break;
|
|
}
|
|
|
|
// optional .tensorflow.TensorShapeProto tensor_shape = 2;
|
|
case 2: {
|
|
if (tag == 18) {
|
|
parse_tensor_shape:
|
|
DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
|
|
input, mutable_tensor_shape()));
|
|
} else {
|
|
goto handle_unusual;
|
|
}
|
|
if (input->ExpectTag(24)) goto parse_version_number;
|
|
break;
|
|
}
|
|
|
|
// optional int32 version_number = 3;
|
|
case 3: {
|
|
if (tag == 24) {
|
|
parse_version_number:
|
|
|
|
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
|
|
::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
|
|
input, &version_number_)));
|
|
} else {
|
|
goto handle_unusual;
|
|
}
|
|
if (input->ExpectTag(34)) goto parse_tensor_content;
|
|
break;
|
|
}
|
|
|
|
// optional bytes tensor_content = 4;
|
|
case 4: {
|
|
if (tag == 34) {
|
|
parse_tensor_content:
|
|
DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
|
|
input, this->mutable_tensor_content()));
|
|
} else {
|
|
goto handle_unusual;
|
|
}
|
|
if (input->ExpectTag(42)) goto parse_float_val;
|
|
break;
|
|
}
|
|
|
|
// repeated float float_val = 5 [packed = true];
|
|
case 5: {
|
|
if (tag == 42) {
|
|
parse_float_val:
|
|
DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitive<
|
|
float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
|
|
input, this->mutable_float_val())));
|
|
} else if (tag == 45) {
|
|
DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline<
|
|
float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
|
|
1, 42, input, this->mutable_float_val())));
|
|
} else {
|
|
goto handle_unusual;
|
|
}
|
|
if (input->ExpectTag(50)) goto parse_double_val;
|
|
break;
|
|
}
|
|
|
|
// repeated double double_val = 6 [packed = true];
|
|
case 6: {
|
|
if (tag == 50) {
|
|
parse_double_val:
|
|
DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitive<
|
|
double, ::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE>(
|
|
input, this->mutable_double_val())));
|
|
} else if (tag == 49) {
|
|
DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline<
|
|
double, ::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE>(
|
|
1, 50, input, this->mutable_double_val())));
|
|
} else {
|
|
goto handle_unusual;
|
|
}
|
|
if (input->ExpectTag(58)) goto parse_int_val;
|
|
break;
|
|
}
|
|
|
|
// repeated int32 int_val = 7 [packed = true];
|
|
case 7: {
|
|
if (tag == 58) {
|
|
parse_int_val:
|
|
DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitive<
|
|
::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
|
|
input, this->mutable_int_val())));
|
|
} else if (tag == 56) {
|
|
DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline<
|
|
::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
|
|
1, 58, input, this->mutable_int_val())));
|
|
} else {
|
|
goto handle_unusual;
|
|
}
|
|
if (input->ExpectTag(66)) goto parse_string_val;
|
|
break;
|
|
}
|
|
|
|
// repeated bytes string_val = 8;
|
|
case 8: {
|
|
if (tag == 66) {
|
|
parse_string_val:
|
|
DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
|
|
input, this->add_string_val()));
|
|
} else {
|
|
goto handle_unusual;
|
|
}
|
|
if (input->ExpectTag(66)) goto parse_string_val;
|
|
if (input->ExpectTag(74)) goto parse_scomplex_val;
|
|
break;
|
|
}
|
|
|
|
// repeated float scomplex_val = 9 [packed = true];
|
|
case 9: {
|
|
if (tag == 74) {
|
|
parse_scomplex_val:
|
|
DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitive<
|
|
float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
|
|
input, this->mutable_scomplex_val())));
|
|
} else if (tag == 77) {
|
|
DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline<
|
|
float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
|
|
1, 74, input, this->mutable_scomplex_val())));
|
|
} else {
|
|
goto handle_unusual;
|
|
}
|
|
if (input->ExpectTag(82)) goto parse_int64_val;
|
|
break;
|
|
}
|
|
|
|
// repeated int64 int64_val = 10 [packed = true];
|
|
case 10: {
|
|
if (tag == 82) {
|
|
parse_int64_val:
|
|
DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitive<
|
|
::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
|
|
input, this->mutable_int64_val())));
|
|
} else if (tag == 80) {
|
|
DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline<
|
|
::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
|
|
1, 82, input, this->mutable_int64_val())));
|
|
} else {
|
|
goto handle_unusual;
|
|
}
|
|
if (input->ExpectTag(90)) goto parse_bool_val;
|
|
break;
|
|
}
|
|
|
|
// repeated bool bool_val = 11 [packed = true];
|
|
case 11: {
|
|
if (tag == 90) {
|
|
parse_bool_val:
|
|
DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitive<
|
|
bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
|
|
input, this->mutable_bool_val())));
|
|
} else if (tag == 88) {
|
|
DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline<
|
|
bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
|
|
1, 90, input, this->mutable_bool_val())));
|
|
} else {
|
|
goto handle_unusual;
|
|
}
|
|
if (input->ExpectTag(98)) goto parse_dcomplex_val;
|
|
break;
|
|
}
|
|
|
|
// repeated double dcomplex_val = 12 [packed = true];
|
|
case 12: {
|
|
if (tag == 98) {
|
|
parse_dcomplex_val:
|
|
DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitive<
|
|
double, ::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE>(
|
|
input, this->mutable_dcomplex_val())));
|
|
} else if (tag == 97) {
|
|
DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline<
|
|
double, ::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE>(
|
|
1, 98, input, this->mutable_dcomplex_val())));
|
|
} else {
|
|
goto handle_unusual;
|
|
}
|
|
if (input->ExpectTag(106)) goto parse_half_val;
|
|
break;
|
|
}
|
|
|
|
// repeated int32 half_val = 13 [packed = true];
|
|
case 13: {
|
|
if (tag == 106) {
|
|
parse_half_val:
|
|
DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitive<
|
|
::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
|
|
input, this->mutable_half_val())));
|
|
} else if (tag == 104) {
|
|
DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline<
|
|
::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
|
|
1, 106, input, this->mutable_half_val())));
|
|
} else {
|
|
goto handle_unusual;
|
|
}
|
|
if (input->ExpectAtEnd()) goto success;
|
|
break;
|
|
}
|
|
|
|
default: {
|
|
handle_unusual:
|
|
if (tag == 0 ||
|
|
::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
|
|
::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
|
|
goto success;
|
|
}
|
|
DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag));
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
success:
|
|
// @@protoc_insertion_point(parse_success:tensorflow.TensorProto)
|
|
return true;
|
|
failure:
|
|
// @@protoc_insertion_point(parse_failure:tensorflow.TensorProto)
|
|
return false;
|
|
#undef DO_
|
|
}
|
|
|
|
void TensorProto::SerializeWithCachedSizes(
|
|
::google::protobuf::io::CodedOutputStream* output) const {
|
|
// @@protoc_insertion_point(serialize_start:tensorflow.TensorProto)
|
|
// optional .tensorflow.DataType dtype = 1;
|
|
if (this->dtype() != 0) {
|
|
::google::protobuf::internal::WireFormatLite::WriteEnum(
|
|
1, this->dtype(), output);
|
|
}
|
|
|
|
// optional .tensorflow.TensorShapeProto tensor_shape = 2;
|
|
if (this->has_tensor_shape()) {
|
|
::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
|
|
2, *this->tensor_shape_, output);
|
|
}
|
|
|
|
// optional int32 version_number = 3;
|
|
if (this->version_number() != 0) {
|
|
::google::protobuf::internal::WireFormatLite::WriteInt32(3, this->version_number(), output);
|
|
}
|
|
|
|
// optional bytes tensor_content = 4;
|
|
if (this->tensor_content().size() > 0) {
|
|
::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
|
|
4, this->tensor_content(), output);
|
|
}
|
|
|
|
// repeated float float_val = 5 [packed = true];
|
|
if (this->float_val_size() > 0) {
|
|
::google::protobuf::internal::WireFormatLite::WriteTag(5, ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output);
|
|
output->WriteVarint32(_float_val_cached_byte_size_);
|
|
}
|
|
for (int i = 0; i < this->float_val_size(); i++) {
|
|
::google::protobuf::internal::WireFormatLite::WriteFloatNoTag(
|
|
this->float_val(i), output);
|
|
}
|
|
|
|
// repeated double double_val = 6 [packed = true];
|
|
if (this->double_val_size() > 0) {
|
|
::google::protobuf::internal::WireFormatLite::WriteTag(6, ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output);
|
|
output->WriteVarint32(_double_val_cached_byte_size_);
|
|
}
|
|
for (int i = 0; i < this->double_val_size(); i++) {
|
|
::google::protobuf::internal::WireFormatLite::WriteDoubleNoTag(
|
|
this->double_val(i), output);
|
|
}
|
|
|
|
// repeated int32 int_val = 7 [packed = true];
|
|
if (this->int_val_size() > 0) {
|
|
::google::protobuf::internal::WireFormatLite::WriteTag(7, ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output);
|
|
output->WriteVarint32(_int_val_cached_byte_size_);
|
|
}
|
|
for (int i = 0; i < this->int_val_size(); i++) {
|
|
::google::protobuf::internal::WireFormatLite::WriteInt32NoTag(
|
|
this->int_val(i), output);
|
|
}
|
|
|
|
// repeated bytes string_val = 8;
|
|
for (int i = 0; i < this->string_val_size(); i++) {
|
|
::google::protobuf::internal::WireFormatLite::WriteBytes(
|
|
8, this->string_val(i), output);
|
|
}
|
|
|
|
// repeated float scomplex_val = 9 [packed = true];
|
|
if (this->scomplex_val_size() > 0) {
|
|
::google::protobuf::internal::WireFormatLite::WriteTag(9, ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output);
|
|
output->WriteVarint32(_scomplex_val_cached_byte_size_);
|
|
}
|
|
for (int i = 0; i < this->scomplex_val_size(); i++) {
|
|
::google::protobuf::internal::WireFormatLite::WriteFloatNoTag(
|
|
this->scomplex_val(i), output);
|
|
}
|
|
|
|
// repeated int64 int64_val = 10 [packed = true];
|
|
if (this->int64_val_size() > 0) {
|
|
::google::protobuf::internal::WireFormatLite::WriteTag(10, ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output);
|
|
output->WriteVarint32(_int64_val_cached_byte_size_);
|
|
}
|
|
for (int i = 0; i < this->int64_val_size(); i++) {
|
|
::google::protobuf::internal::WireFormatLite::WriteInt64NoTag(
|
|
this->int64_val(i), output);
|
|
}
|
|
|
|
// repeated bool bool_val = 11 [packed = true];
|
|
if (this->bool_val_size() > 0) {
|
|
::google::protobuf::internal::WireFormatLite::WriteTag(11, ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output);
|
|
output->WriteVarint32(_bool_val_cached_byte_size_);
|
|
}
|
|
for (int i = 0; i < this->bool_val_size(); i++) {
|
|
::google::protobuf::internal::WireFormatLite::WriteBoolNoTag(
|
|
this->bool_val(i), output);
|
|
}
|
|
|
|
// repeated double dcomplex_val = 12 [packed = true];
|
|
if (this->dcomplex_val_size() > 0) {
|
|
::google::protobuf::internal::WireFormatLite::WriteTag(12, ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output);
|
|
output->WriteVarint32(_dcomplex_val_cached_byte_size_);
|
|
}
|
|
for (int i = 0; i < this->dcomplex_val_size(); i++) {
|
|
::google::protobuf::internal::WireFormatLite::WriteDoubleNoTag(
|
|
this->dcomplex_val(i), output);
|
|
}
|
|
|
|
// repeated int32 half_val = 13 [packed = true];
|
|
if (this->half_val_size() > 0) {
|
|
::google::protobuf::internal::WireFormatLite::WriteTag(13, ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output);
|
|
output->WriteVarint32(_half_val_cached_byte_size_);
|
|
}
|
|
for (int i = 0; i < this->half_val_size(); i++) {
|
|
::google::protobuf::internal::WireFormatLite::WriteInt32NoTag(
|
|
this->half_val(i), output);
|
|
}
|
|
|
|
// @@protoc_insertion_point(serialize_end:tensorflow.TensorProto)
|
|
}
|
|
|
|
::google::protobuf::uint8* TensorProto::InternalSerializeWithCachedSizesToArray(
|
|
bool deterministic, ::google::protobuf::uint8* target) const {
|
|
(void)deterministic; // Unused
|
|
// @@protoc_insertion_point(serialize_to_array_start:tensorflow.TensorProto)
|
|
// optional .tensorflow.DataType dtype = 1;
|
|
if (this->dtype() != 0) {
|
|
target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
|
|
1, this->dtype(), target);
|
|
}
|
|
|
|
// optional .tensorflow.TensorShapeProto tensor_shape = 2;
|
|
if (this->has_tensor_shape()) {
|
|
target = ::google::protobuf::internal::WireFormatLite::
|
|
InternalWriteMessageNoVirtualToArray(
|
|
2, *this->tensor_shape_, false, target);
|
|
}
|
|
|
|
// optional int32 version_number = 3;
|
|
if (this->version_number() != 0) {
|
|
target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(3, this->version_number(), target);
|
|
}
|
|
|
|
// optional bytes tensor_content = 4;
|
|
if (this->tensor_content().size() > 0) {
|
|
target =
|
|
::google::protobuf::internal::WireFormatLite::WriteBytesToArray(
|
|
4, this->tensor_content(), target);
|
|
}
|
|
|
|
// repeated float float_val = 5 [packed = true];
|
|
if (this->float_val_size() > 0) {
|
|
target = ::google::protobuf::internal::WireFormatLite::WriteTagToArray(
|
|
5,
|
|
::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED,
|
|
target);
|
|
target = ::google::protobuf::io::CodedOutputStream::WriteVarint32ToArray(
|
|
_float_val_cached_byte_size_, target);
|
|
}
|
|
for (int i = 0; i < this->float_val_size(); i++) {
|
|
target = ::google::protobuf::internal::WireFormatLite::
|
|
WriteFloatNoTagToArray(this->float_val(i), target);
|
|
}
|
|
|
|
// repeated double double_val = 6 [packed = true];
|
|
if (this->double_val_size() > 0) {
|
|
target = ::google::protobuf::internal::WireFormatLite::WriteTagToArray(
|
|
6,
|
|
::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED,
|
|
target);
|
|
target = ::google::protobuf::io::CodedOutputStream::WriteVarint32ToArray(
|
|
_double_val_cached_byte_size_, target);
|
|
}
|
|
for (int i = 0; i < this->double_val_size(); i++) {
|
|
target = ::google::protobuf::internal::WireFormatLite::
|
|
WriteDoubleNoTagToArray(this->double_val(i), target);
|
|
}
|
|
|
|
// repeated int32 int_val = 7 [packed = true];
|
|
if (this->int_val_size() > 0) {
|
|
target = ::google::protobuf::internal::WireFormatLite::WriteTagToArray(
|
|
7,
|
|
::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED,
|
|
target);
|
|
target = ::google::protobuf::io::CodedOutputStream::WriteVarint32ToArray(
|
|
_int_val_cached_byte_size_, target);
|
|
}
|
|
for (int i = 0; i < this->int_val_size(); i++) {
|
|
target = ::google::protobuf::internal::WireFormatLite::
|
|
WriteInt32NoTagToArray(this->int_val(i), target);
|
|
}
|
|
|
|
// repeated bytes string_val = 8;
|
|
for (int i = 0; i < this->string_val_size(); i++) {
|
|
target = ::google::protobuf::internal::WireFormatLite::
|
|
WriteBytesToArray(8, this->string_val(i), target);
|
|
}
|
|
|
|
// repeated float scomplex_val = 9 [packed = true];
|
|
if (this->scomplex_val_size() > 0) {
|
|
target = ::google::protobuf::internal::WireFormatLite::WriteTagToArray(
|
|
9,
|
|
::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED,
|
|
target);
|
|
target = ::google::protobuf::io::CodedOutputStream::WriteVarint32ToArray(
|
|
_scomplex_val_cached_byte_size_, target);
|
|
}
|
|
for (int i = 0; i < this->scomplex_val_size(); i++) {
|
|
target = ::google::protobuf::internal::WireFormatLite::
|
|
WriteFloatNoTagToArray(this->scomplex_val(i), target);
|
|
}
|
|
|
|
// repeated int64 int64_val = 10 [packed = true];
|
|
if (this->int64_val_size() > 0) {
|
|
target = ::google::protobuf::internal::WireFormatLite::WriteTagToArray(
|
|
10,
|
|
::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED,
|
|
target);
|
|
target = ::google::protobuf::io::CodedOutputStream::WriteVarint32ToArray(
|
|
_int64_val_cached_byte_size_, target);
|
|
}
|
|
for (int i = 0; i < this->int64_val_size(); i++) {
|
|
target = ::google::protobuf::internal::WireFormatLite::
|
|
WriteInt64NoTagToArray(this->int64_val(i), target);
|
|
}
|
|
|
|
// repeated bool bool_val = 11 [packed = true];
|
|
if (this->bool_val_size() > 0) {
|
|
target = ::google::protobuf::internal::WireFormatLite::WriteTagToArray(
|
|
11,
|
|
::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED,
|
|
target);
|
|
target = ::google::protobuf::io::CodedOutputStream::WriteVarint32ToArray(
|
|
_bool_val_cached_byte_size_, target);
|
|
}
|
|
for (int i = 0; i < this->bool_val_size(); i++) {
|
|
target = ::google::protobuf::internal::WireFormatLite::
|
|
WriteBoolNoTagToArray(this->bool_val(i), target);
|
|
}
|
|
|
|
// repeated double dcomplex_val = 12 [packed = true];
|
|
if (this->dcomplex_val_size() > 0) {
|
|
target = ::google::protobuf::internal::WireFormatLite::WriteTagToArray(
|
|
12,
|
|
::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED,
|
|
target);
|
|
target = ::google::protobuf::io::CodedOutputStream::WriteVarint32ToArray(
|
|
_dcomplex_val_cached_byte_size_, target);
|
|
}
|
|
for (int i = 0; i < this->dcomplex_val_size(); i++) {
|
|
target = ::google::protobuf::internal::WireFormatLite::
|
|
WriteDoubleNoTagToArray(this->dcomplex_val(i), target);
|
|
}
|
|
|
|
// repeated int32 half_val = 13 [packed = true];
|
|
if (this->half_val_size() > 0) {
|
|
target = ::google::protobuf::internal::WireFormatLite::WriteTagToArray(
|
|
13,
|
|
::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED,
|
|
target);
|
|
target = ::google::protobuf::io::CodedOutputStream::WriteVarint32ToArray(
|
|
_half_val_cached_byte_size_, target);
|
|
}
|
|
for (int i = 0; i < this->half_val_size(); i++) {
|
|
target = ::google::protobuf::internal::WireFormatLite::
|
|
WriteInt32NoTagToArray(this->half_val(i), target);
|
|
}
|
|
|
|
// @@protoc_insertion_point(serialize_to_array_end:tensorflow.TensorProto)
|
|
return target;
|
|
}
|
|
|
|
size_t TensorProto::ByteSizeLong() const {
|
|
// @@protoc_insertion_point(message_byte_size_start:tensorflow.TensorProto)
|
|
size_t total_size = 0;
|
|
|
|
// optional .tensorflow.DataType dtype = 1;
|
|
if (this->dtype() != 0) {
|
|
total_size += 1 +
|
|
::google::protobuf::internal::WireFormatLite::EnumSize(this->dtype());
|
|
}
|
|
|
|
// optional .tensorflow.TensorShapeProto tensor_shape = 2;
|
|
if (this->has_tensor_shape()) {
|
|
total_size += 1 +
|
|
::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
|
|
*this->tensor_shape_);
|
|
}
|
|
|
|
// optional int32 version_number = 3;
|
|
if (this->version_number() != 0) {
|
|
total_size += 1 +
|
|
::google::protobuf::internal::WireFormatLite::Int32Size(
|
|
this->version_number());
|
|
}
|
|
|
|
// optional bytes tensor_content = 4;
|
|
if (this->tensor_content().size() > 0) {
|
|
total_size += 1 +
|
|
::google::protobuf::internal::WireFormatLite::BytesSize(
|
|
this->tensor_content());
|
|
}
|
|
|
|
// repeated int32 half_val = 13 [packed = true];
|
|
{
|
|
size_t data_size = 0;
|
|
unsigned int count = this->half_val_size();
|
|
for (unsigned int i = 0; i < count; i++) {
|
|
data_size += ::google::protobuf::internal::WireFormatLite::
|
|
Int32Size(this->half_val(i));
|
|
}
|
|
if (data_size > 0) {
|
|
total_size += 1 +
|
|
::google::protobuf::internal::WireFormatLite::Int32Size(data_size);
|
|
}
|
|
int cached_size = ::google::protobuf::internal::ToCachedSize(data_size);
|
|
GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
|
|
_half_val_cached_byte_size_ = cached_size;
|
|
GOOGLE_SAFE_CONCURRENT_WRITES_END();
|
|
total_size += data_size;
|
|
}
|
|
|
|
// repeated float float_val = 5 [packed = true];
|
|
{
|
|
size_t data_size = 0;
|
|
unsigned int count = this->float_val_size();
|
|
data_size = 4UL * count;
|
|
if (data_size > 0) {
|
|
total_size += 1 +
|
|
::google::protobuf::internal::WireFormatLite::Int32Size(data_size);
|
|
}
|
|
int cached_size = ::google::protobuf::internal::ToCachedSize(data_size);
|
|
GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
|
|
_float_val_cached_byte_size_ = cached_size;
|
|
GOOGLE_SAFE_CONCURRENT_WRITES_END();
|
|
total_size += data_size;
|
|
}
|
|
|
|
// repeated double double_val = 6 [packed = true];
|
|
{
|
|
size_t data_size = 0;
|
|
unsigned int count = this->double_val_size();
|
|
data_size = 8UL * count;
|
|
if (data_size > 0) {
|
|
total_size += 1 +
|
|
::google::protobuf::internal::WireFormatLite::Int32Size(data_size);
|
|
}
|
|
int cached_size = ::google::protobuf::internal::ToCachedSize(data_size);
|
|
GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
|
|
_double_val_cached_byte_size_ = cached_size;
|
|
GOOGLE_SAFE_CONCURRENT_WRITES_END();
|
|
total_size += data_size;
|
|
}
|
|
|
|
// repeated int32 int_val = 7 [packed = true];
|
|
{
|
|
size_t data_size = 0;
|
|
unsigned int count = this->int_val_size();
|
|
for (unsigned int i = 0; i < count; i++) {
|
|
data_size += ::google::protobuf::internal::WireFormatLite::
|
|
Int32Size(this->int_val(i));
|
|
}
|
|
if (data_size > 0) {
|
|
total_size += 1 +
|
|
::google::protobuf::internal::WireFormatLite::Int32Size(data_size);
|
|
}
|
|
int cached_size = ::google::protobuf::internal::ToCachedSize(data_size);
|
|
GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
|
|
_int_val_cached_byte_size_ = cached_size;
|
|
GOOGLE_SAFE_CONCURRENT_WRITES_END();
|
|
total_size += data_size;
|
|
}
|
|
|
|
// repeated bytes string_val = 8;
|
|
total_size += 1 *
|
|
::google::protobuf::internal::FromIntSize(this->string_val_size());
|
|
for (int i = 0; i < this->string_val_size(); i++) {
|
|
total_size += ::google::protobuf::internal::WireFormatLite::BytesSize(
|
|
this->string_val(i));
|
|
}
|
|
|
|
// repeated float scomplex_val = 9 [packed = true];
|
|
{
|
|
size_t data_size = 0;
|
|
unsigned int count = this->scomplex_val_size();
|
|
data_size = 4UL * count;
|
|
if (data_size > 0) {
|
|
total_size += 1 +
|
|
::google::protobuf::internal::WireFormatLite::Int32Size(data_size);
|
|
}
|
|
int cached_size = ::google::protobuf::internal::ToCachedSize(data_size);
|
|
GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
|
|
_scomplex_val_cached_byte_size_ = cached_size;
|
|
GOOGLE_SAFE_CONCURRENT_WRITES_END();
|
|
total_size += data_size;
|
|
}
|
|
|
|
// repeated int64 int64_val = 10 [packed = true];
|
|
{
|
|
size_t data_size = 0;
|
|
unsigned int count = this->int64_val_size();
|
|
for (unsigned int i = 0; i < count; i++) {
|
|
data_size += ::google::protobuf::internal::WireFormatLite::
|
|
Int64Size(this->int64_val(i));
|
|
}
|
|
if (data_size > 0) {
|
|
total_size += 1 +
|
|
::google::protobuf::internal::WireFormatLite::Int32Size(data_size);
|
|
}
|
|
int cached_size = ::google::protobuf::internal::ToCachedSize(data_size);
|
|
GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
|
|
_int64_val_cached_byte_size_ = cached_size;
|
|
GOOGLE_SAFE_CONCURRENT_WRITES_END();
|
|
total_size += data_size;
|
|
}
|
|
|
|
// repeated bool bool_val = 11 [packed = true];
|
|
{
|
|
size_t data_size = 0;
|
|
unsigned int count = this->bool_val_size();
|
|
data_size = 1UL * count;
|
|
if (data_size > 0) {
|
|
total_size += 1 +
|
|
::google::protobuf::internal::WireFormatLite::Int32Size(data_size);
|
|
}
|
|
int cached_size = ::google::protobuf::internal::ToCachedSize(data_size);
|
|
GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
|
|
_bool_val_cached_byte_size_ = cached_size;
|
|
GOOGLE_SAFE_CONCURRENT_WRITES_END();
|
|
total_size += data_size;
|
|
}
|
|
|
|
// repeated double dcomplex_val = 12 [packed = true];
|
|
{
|
|
size_t data_size = 0;
|
|
unsigned int count = this->dcomplex_val_size();
|
|
data_size = 8UL * count;
|
|
if (data_size > 0) {
|
|
total_size += 1 +
|
|
::google::protobuf::internal::WireFormatLite::Int32Size(data_size);
|
|
}
|
|
int cached_size = ::google::protobuf::internal::ToCachedSize(data_size);
|
|
GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
|
|
_dcomplex_val_cached_byte_size_ = cached_size;
|
|
GOOGLE_SAFE_CONCURRENT_WRITES_END();
|
|
total_size += data_size;
|
|
}
|
|
|
|
int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
|
|
GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
|
|
_cached_size_ = cached_size;
|
|
GOOGLE_SAFE_CONCURRENT_WRITES_END();
|
|
return total_size;
|
|
}
|
|
|
|
void TensorProto::MergeFrom(const ::google::protobuf::Message& from) {
|
|
// @@protoc_insertion_point(generalized_merge_from_start:tensorflow.TensorProto)
|
|
if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__);
|
|
const TensorProto* source =
|
|
::google::protobuf::internal::DynamicCastToGenerated<const TensorProto>(
|
|
&from);
|
|
if (source == NULL) {
|
|
// @@protoc_insertion_point(generalized_merge_from_cast_fail:tensorflow.TensorProto)
|
|
::google::protobuf::internal::ReflectionOps::Merge(from, this);
|
|
} else {
|
|
// @@protoc_insertion_point(generalized_merge_from_cast_success:tensorflow.TensorProto)
|
|
UnsafeMergeFrom(*source);
|
|
}
|
|
}
|
|
|
|
void TensorProto::MergeFrom(const TensorProto& from) {
|
|
// @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.TensorProto)
|
|
if (GOOGLE_PREDICT_TRUE(&from != this)) {
|
|
UnsafeMergeFrom(from);
|
|
} else {
|
|
MergeFromFail(__LINE__);
|
|
}
|
|
}
|
|
|
|
void TensorProto::UnsafeMergeFrom(const TensorProto& from) {
|
|
GOOGLE_DCHECK(&from != this);
|
|
half_val_.UnsafeMergeFrom(from.half_val_);
|
|
float_val_.UnsafeMergeFrom(from.float_val_);
|
|
double_val_.UnsafeMergeFrom(from.double_val_);
|
|
int_val_.UnsafeMergeFrom(from.int_val_);
|
|
string_val_.UnsafeMergeFrom(from.string_val_);
|
|
scomplex_val_.UnsafeMergeFrom(from.scomplex_val_);
|
|
int64_val_.UnsafeMergeFrom(from.int64_val_);
|
|
bool_val_.UnsafeMergeFrom(from.bool_val_);
|
|
dcomplex_val_.UnsafeMergeFrom(from.dcomplex_val_);
|
|
if (from.dtype() != 0) {
|
|
set_dtype(from.dtype());
|
|
}
|
|
if (from.has_tensor_shape()) {
|
|
mutable_tensor_shape()->::tensorflow::TensorShapeProto::MergeFrom(from.tensor_shape());
|
|
}
|
|
if (from.version_number() != 0) {
|
|
set_version_number(from.version_number());
|
|
}
|
|
if (from.tensor_content().size() > 0) {
|
|
set_tensor_content(from.tensor_content());
|
|
}
|
|
}
|
|
|
|
void TensorProto::CopyFrom(const ::google::protobuf::Message& from) {
|
|
// @@protoc_insertion_point(generalized_copy_from_start:tensorflow.TensorProto)
|
|
if (&from == this) return;
|
|
Clear();
|
|
MergeFrom(from);
|
|
}
|
|
|
|
void TensorProto::CopyFrom(const TensorProto& from) {
|
|
// @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.TensorProto)
|
|
if (&from == this) return;
|
|
Clear();
|
|
UnsafeMergeFrom(from);
|
|
}
|
|
|
|
bool TensorProto::IsInitialized() const {
|
|
|
|
return true;
|
|
}
|
|
|
|
void TensorProto::Swap(TensorProto* other) {
|
|
if (other == this) return;
|
|
if (GetArenaNoVirtual() == other->GetArenaNoVirtual()) {
|
|
InternalSwap(other);
|
|
} else {
|
|
TensorProto temp;
|
|
temp.UnsafeMergeFrom(*this);
|
|
CopyFrom(*other);
|
|
other->CopyFrom(temp);
|
|
}
|
|
}
|
|
void TensorProto::UnsafeArenaSwap(TensorProto* other) {
|
|
if (other == this) return;
|
|
GOOGLE_DCHECK(GetArenaNoVirtual() == other->GetArenaNoVirtual());
|
|
InternalSwap(other);
|
|
}
|
|
void TensorProto::InternalSwap(TensorProto* other) {
|
|
std::swap(dtype_, other->dtype_);
|
|
std::swap(tensor_shape_, other->tensor_shape_);
|
|
std::swap(version_number_, other->version_number_);
|
|
tensor_content_.Swap(&other->tensor_content_);
|
|
half_val_.UnsafeArenaSwap(&other->half_val_);
|
|
float_val_.UnsafeArenaSwap(&other->float_val_);
|
|
double_val_.UnsafeArenaSwap(&other->double_val_);
|
|
int_val_.UnsafeArenaSwap(&other->int_val_);
|
|
string_val_.UnsafeArenaSwap(&other->string_val_);
|
|
scomplex_val_.UnsafeArenaSwap(&other->scomplex_val_);
|
|
int64_val_.UnsafeArenaSwap(&other->int64_val_);
|
|
bool_val_.UnsafeArenaSwap(&other->bool_val_);
|
|
dcomplex_val_.UnsafeArenaSwap(&other->dcomplex_val_);
|
|
_internal_metadata_.Swap(&other->_internal_metadata_);
|
|
std::swap(_cached_size_, other->_cached_size_);
|
|
}
|
|
|
|
::google::protobuf::Metadata TensorProto::GetMetadata() const {
|
|
protobuf_AssignDescriptorsOnce();
|
|
::google::protobuf::Metadata metadata;
|
|
metadata.descriptor = TensorProto_descriptor_;
|
|
metadata.reflection = TensorProto_reflection_;
|
|
return metadata;
|
|
}
|
|
|
|
#if PROTOBUF_INLINE_NOT_IN_HEADERS
|
|
// TensorProto
|
|
|
|
// optional .tensorflow.DataType dtype = 1;
|
|
void TensorProto::clear_dtype() {
|
|
dtype_ = 0;
|
|
}
|
|
::tensorflow::DataType TensorProto::dtype() const {
|
|
// @@protoc_insertion_point(field_get:tensorflow.TensorProto.dtype)
|
|
return static_cast< ::tensorflow::DataType >(dtype_);
|
|
}
|
|
void TensorProto::set_dtype(::tensorflow::DataType value) {
|
|
|
|
dtype_ = value;
|
|
// @@protoc_insertion_point(field_set:tensorflow.TensorProto.dtype)
|
|
}
|
|
|
|
// optional .tensorflow.TensorShapeProto tensor_shape = 2;
|
|
bool TensorProto::has_tensor_shape() const {
|
|
return this != internal_default_instance() && tensor_shape_ != NULL;
|
|
}
|
|
void TensorProto::clear_tensor_shape() {
|
|
if (GetArenaNoVirtual() == NULL && tensor_shape_ != NULL) delete tensor_shape_;
|
|
tensor_shape_ = NULL;
|
|
}
|
|
const ::tensorflow::TensorShapeProto& TensorProto::tensor_shape() const {
|
|
// @@protoc_insertion_point(field_get:tensorflow.TensorProto.tensor_shape)
|
|
return tensor_shape_ != NULL ? *tensor_shape_
|
|
: *::tensorflow::TensorShapeProto::internal_default_instance();
|
|
}
|
|
::tensorflow::TensorShapeProto* TensorProto::mutable_tensor_shape() {
|
|
|
|
if (tensor_shape_ == NULL) {
|
|
_slow_mutable_tensor_shape();
|
|
}
|
|
// @@protoc_insertion_point(field_mutable:tensorflow.TensorProto.tensor_shape)
|
|
return tensor_shape_;
|
|
}
|
|
::tensorflow::TensorShapeProto* TensorProto::release_tensor_shape() {
|
|
// @@protoc_insertion_point(field_release:tensorflow.TensorProto.tensor_shape)
|
|
|
|
if (GetArenaNoVirtual() != NULL) {
|
|
return _slow_release_tensor_shape();
|
|
} else {
|
|
::tensorflow::TensorShapeProto* temp = tensor_shape_;
|
|
tensor_shape_ = NULL;
|
|
return temp;
|
|
}
|
|
}
|
|
void TensorProto::set_allocated_tensor_shape(::tensorflow::TensorShapeProto* tensor_shape) {
|
|
::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
|
|
if (message_arena == NULL) {
|
|
delete tensor_shape_;
|
|
}
|
|
if (tensor_shape != NULL) {
|
|
_slow_set_allocated_tensor_shape(message_arena, &tensor_shape);
|
|
}
|
|
tensor_shape_ = tensor_shape;
|
|
if (tensor_shape) {
|
|
|
|
} else {
|
|
|
|
}
|
|
// @@protoc_insertion_point(field_set_allocated:tensorflow.TensorProto.tensor_shape)
|
|
}
|
|
|
|
// optional int32 version_number = 3;
|
|
void TensorProto::clear_version_number() {
|
|
version_number_ = 0;
|
|
}
|
|
::google::protobuf::int32 TensorProto::version_number() const {
|
|
// @@protoc_insertion_point(field_get:tensorflow.TensorProto.version_number)
|
|
return version_number_;
|
|
}
|
|
void TensorProto::set_version_number(::google::protobuf::int32 value) {
|
|
|
|
version_number_ = value;
|
|
// @@protoc_insertion_point(field_set:tensorflow.TensorProto.version_number)
|
|
}
|
|
|
|
// optional bytes tensor_content = 4;
|
|
void TensorProto::clear_tensor_content() {
|
|
tensor_content_.ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
|
|
}
|
|
const ::std::string& TensorProto::tensor_content() const {
|
|
// @@protoc_insertion_point(field_get:tensorflow.TensorProto.tensor_content)
|
|
return tensor_content_.Get(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
|
|
}
|
|
void TensorProto::set_tensor_content(const ::std::string& value) {
|
|
|
|
tensor_content_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual());
|
|
// @@protoc_insertion_point(field_set:tensorflow.TensorProto.tensor_content)
|
|
}
|
|
void TensorProto::set_tensor_content(const char* value) {
|
|
|
|
tensor_content_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
|
|
GetArenaNoVirtual());
|
|
// @@protoc_insertion_point(field_set_char:tensorflow.TensorProto.tensor_content)
|
|
}
|
|
void TensorProto::set_tensor_content(const void* value,
|
|
size_t size) {
|
|
|
|
tensor_content_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(
|
|
reinterpret_cast<const char*>(value), size), GetArenaNoVirtual());
|
|
// @@protoc_insertion_point(field_set_pointer:tensorflow.TensorProto.tensor_content)
|
|
}
|
|
::std::string* TensorProto::mutable_tensor_content() {
|
|
|
|
// @@protoc_insertion_point(field_mutable:tensorflow.TensorProto.tensor_content)
|
|
return tensor_content_.Mutable(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
|
|
}
|
|
::std::string* TensorProto::release_tensor_content() {
|
|
// @@protoc_insertion_point(field_release:tensorflow.TensorProto.tensor_content)
|
|
|
|
return tensor_content_.Release(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
|
|
}
|
|
::std::string* TensorProto::unsafe_arena_release_tensor_content() {
|
|
// @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.TensorProto.tensor_content)
|
|
GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
|
|
|
|
return tensor_content_.UnsafeArenaRelease(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
|
|
GetArenaNoVirtual());
|
|
}
|
|
void TensorProto::set_allocated_tensor_content(::std::string* tensor_content) {
|
|
if (tensor_content != NULL) {
|
|
|
|
} else {
|
|
|
|
}
|
|
tensor_content_.SetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), tensor_content,
|
|
GetArenaNoVirtual());
|
|
// @@protoc_insertion_point(field_set_allocated:tensorflow.TensorProto.tensor_content)
|
|
}
|
|
void TensorProto::unsafe_arena_set_allocated_tensor_content(
|
|
::std::string* tensor_content) {
|
|
GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
|
|
if (tensor_content != NULL) {
|
|
|
|
} else {
|
|
|
|
}
|
|
tensor_content_.UnsafeArenaSetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
|
|
tensor_content, GetArenaNoVirtual());
|
|
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.TensorProto.tensor_content)
|
|
}
|
|
|
|
// repeated int32 half_val = 13 [packed = true];
|
|
int TensorProto::half_val_size() const {
|
|
return half_val_.size();
|
|
}
|
|
void TensorProto::clear_half_val() {
|
|
half_val_.Clear();
|
|
}
|
|
::google::protobuf::int32 TensorProto::half_val(int index) const {
|
|
// @@protoc_insertion_point(field_get:tensorflow.TensorProto.half_val)
|
|
return half_val_.Get(index);
|
|
}
|
|
void TensorProto::set_half_val(int index, ::google::protobuf::int32 value) {
|
|
half_val_.Set(index, value);
|
|
// @@protoc_insertion_point(field_set:tensorflow.TensorProto.half_val)
|
|
}
|
|
void TensorProto::add_half_val(::google::protobuf::int32 value) {
|
|
half_val_.Add(value);
|
|
// @@protoc_insertion_point(field_add:tensorflow.TensorProto.half_val)
|
|
}
|
|
const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
|
|
TensorProto::half_val() const {
|
|
// @@protoc_insertion_point(field_list:tensorflow.TensorProto.half_val)
|
|
return half_val_;
|
|
}
|
|
::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
|
|
TensorProto::mutable_half_val() {
|
|
// @@protoc_insertion_point(field_mutable_list:tensorflow.TensorProto.half_val)
|
|
return &half_val_;
|
|
}
|
|
|
|
// repeated float float_val = 5 [packed = true];
|
|
int TensorProto::float_val_size() const {
|
|
return float_val_.size();
|
|
}
|
|
void TensorProto::clear_float_val() {
|
|
float_val_.Clear();
|
|
}
|
|
float TensorProto::float_val(int index) const {
|
|
// @@protoc_insertion_point(field_get:tensorflow.TensorProto.float_val)
|
|
return float_val_.Get(index);
|
|
}
|
|
void TensorProto::set_float_val(int index, float value) {
|
|
float_val_.Set(index, value);
|
|
// @@protoc_insertion_point(field_set:tensorflow.TensorProto.float_val)
|
|
}
|
|
void TensorProto::add_float_val(float value) {
|
|
float_val_.Add(value);
|
|
// @@protoc_insertion_point(field_add:tensorflow.TensorProto.float_val)
|
|
}
|
|
const ::google::protobuf::RepeatedField< float >&
|
|
TensorProto::float_val() const {
|
|
// @@protoc_insertion_point(field_list:tensorflow.TensorProto.float_val)
|
|
return float_val_;
|
|
}
|
|
::google::protobuf::RepeatedField< float >*
|
|
TensorProto::mutable_float_val() {
|
|
// @@protoc_insertion_point(field_mutable_list:tensorflow.TensorProto.float_val)
|
|
return &float_val_;
|
|
}
|
|
|
|
// repeated double double_val = 6 [packed = true];
|
|
int TensorProto::double_val_size() const {
|
|
return double_val_.size();
|
|
}
|
|
void TensorProto::clear_double_val() {
|
|
double_val_.Clear();
|
|
}
|
|
double TensorProto::double_val(int index) const {
|
|
// @@protoc_insertion_point(field_get:tensorflow.TensorProto.double_val)
|
|
return double_val_.Get(index);
|
|
}
|
|
void TensorProto::set_double_val(int index, double value) {
|
|
double_val_.Set(index, value);
|
|
// @@protoc_insertion_point(field_set:tensorflow.TensorProto.double_val)
|
|
}
|
|
void TensorProto::add_double_val(double value) {
|
|
double_val_.Add(value);
|
|
// @@protoc_insertion_point(field_add:tensorflow.TensorProto.double_val)
|
|
}
|
|
const ::google::protobuf::RepeatedField< double >&
|
|
TensorProto::double_val() const {
|
|
// @@protoc_insertion_point(field_list:tensorflow.TensorProto.double_val)
|
|
return double_val_;
|
|
}
|
|
::google::protobuf::RepeatedField< double >*
|
|
TensorProto::mutable_double_val() {
|
|
// @@protoc_insertion_point(field_mutable_list:tensorflow.TensorProto.double_val)
|
|
return &double_val_;
|
|
}
|
|
|
|
// repeated int32 int_val = 7 [packed = true];
|
|
int TensorProto::int_val_size() const {
|
|
return int_val_.size();
|
|
}
|
|
void TensorProto::clear_int_val() {
|
|
int_val_.Clear();
|
|
}
|
|
::google::protobuf::int32 TensorProto::int_val(int index) const {
|
|
// @@protoc_insertion_point(field_get:tensorflow.TensorProto.int_val)
|
|
return int_val_.Get(index);
|
|
}
|
|
void TensorProto::set_int_val(int index, ::google::protobuf::int32 value) {
|
|
int_val_.Set(index, value);
|
|
// @@protoc_insertion_point(field_set:tensorflow.TensorProto.int_val)
|
|
}
|
|
void TensorProto::add_int_val(::google::protobuf::int32 value) {
|
|
int_val_.Add(value);
|
|
// @@protoc_insertion_point(field_add:tensorflow.TensorProto.int_val)
|
|
}
|
|
const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
|
|
TensorProto::int_val() const {
|
|
// @@protoc_insertion_point(field_list:tensorflow.TensorProto.int_val)
|
|
return int_val_;
|
|
}
|
|
::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
|
|
TensorProto::mutable_int_val() {
|
|
// @@protoc_insertion_point(field_mutable_list:tensorflow.TensorProto.int_val)
|
|
return &int_val_;
|
|
}
|
|
|
|
// repeated bytes string_val = 8;
|
|
int TensorProto::string_val_size() const {
|
|
return string_val_.size();
|
|
}
|
|
void TensorProto::clear_string_val() {
|
|
string_val_.Clear();
|
|
}
|
|
const ::std::string& TensorProto::string_val(int index) const {
|
|
// @@protoc_insertion_point(field_get:tensorflow.TensorProto.string_val)
|
|
return string_val_.Get(index);
|
|
}
|
|
::std::string* TensorProto::mutable_string_val(int index) {
|
|
// @@protoc_insertion_point(field_mutable:tensorflow.TensorProto.string_val)
|
|
return string_val_.Mutable(index);
|
|
}
|
|
void TensorProto::set_string_val(int index, const ::std::string& value) {
|
|
// @@protoc_insertion_point(field_set:tensorflow.TensorProto.string_val)
|
|
string_val_.Mutable(index)->assign(value);
|
|
}
|
|
void TensorProto::set_string_val(int index, const char* value) {
|
|
string_val_.Mutable(index)->assign(value);
|
|
// @@protoc_insertion_point(field_set_char:tensorflow.TensorProto.string_val)
|
|
}
|
|
void TensorProto::set_string_val(int index, const void* value, size_t size) {
|
|
string_val_.Mutable(index)->assign(
|
|
reinterpret_cast<const char*>(value), size);
|
|
// @@protoc_insertion_point(field_set_pointer:tensorflow.TensorProto.string_val)
|
|
}
|
|
::std::string* TensorProto::add_string_val() {
|
|
// @@protoc_insertion_point(field_add_mutable:tensorflow.TensorProto.string_val)
|
|
return string_val_.Add();
|
|
}
|
|
void TensorProto::add_string_val(const ::std::string& value) {
|
|
string_val_.Add()->assign(value);
|
|
// @@protoc_insertion_point(field_add:tensorflow.TensorProto.string_val)
|
|
}
|
|
void TensorProto::add_string_val(const char* value) {
|
|
string_val_.Add()->assign(value);
|
|
// @@protoc_insertion_point(field_add_char:tensorflow.TensorProto.string_val)
|
|
}
|
|
void TensorProto::add_string_val(const void* value, size_t size) {
|
|
string_val_.Add()->assign(reinterpret_cast<const char*>(value), size);
|
|
// @@protoc_insertion_point(field_add_pointer:tensorflow.TensorProto.string_val)
|
|
}
|
|
const ::google::protobuf::RepeatedPtrField< ::std::string>&
|
|
TensorProto::string_val() const {
|
|
// @@protoc_insertion_point(field_list:tensorflow.TensorProto.string_val)
|
|
return string_val_;
|
|
}
|
|
::google::protobuf::RepeatedPtrField< ::std::string>*
|
|
TensorProto::mutable_string_val() {
|
|
// @@protoc_insertion_point(field_mutable_list:tensorflow.TensorProto.string_val)
|
|
return &string_val_;
|
|
}
|
|
|
|
// repeated float scomplex_val = 9 [packed = true];
|
|
int TensorProto::scomplex_val_size() const {
|
|
return scomplex_val_.size();
|
|
}
|
|
void TensorProto::clear_scomplex_val() {
|
|
scomplex_val_.Clear();
|
|
}
|
|
float TensorProto::scomplex_val(int index) const {
|
|
// @@protoc_insertion_point(field_get:tensorflow.TensorProto.scomplex_val)
|
|
return scomplex_val_.Get(index);
|
|
}
|
|
void TensorProto::set_scomplex_val(int index, float value) {
|
|
scomplex_val_.Set(index, value);
|
|
// @@protoc_insertion_point(field_set:tensorflow.TensorProto.scomplex_val)
|
|
}
|
|
void TensorProto::add_scomplex_val(float value) {
|
|
scomplex_val_.Add(value);
|
|
// @@protoc_insertion_point(field_add:tensorflow.TensorProto.scomplex_val)
|
|
}
|
|
const ::google::protobuf::RepeatedField< float >&
|
|
TensorProto::scomplex_val() const {
|
|
// @@protoc_insertion_point(field_list:tensorflow.TensorProto.scomplex_val)
|
|
return scomplex_val_;
|
|
}
|
|
::google::protobuf::RepeatedField< float >*
|
|
TensorProto::mutable_scomplex_val() {
|
|
// @@protoc_insertion_point(field_mutable_list:tensorflow.TensorProto.scomplex_val)
|
|
return &scomplex_val_;
|
|
}
|
|
|
|
// repeated int64 int64_val = 10 [packed = true];
|
|
int TensorProto::int64_val_size() const {
|
|
return int64_val_.size();
|
|
}
|
|
void TensorProto::clear_int64_val() {
|
|
int64_val_.Clear();
|
|
}
|
|
::google::protobuf::int64 TensorProto::int64_val(int index) const {
|
|
// @@protoc_insertion_point(field_get:tensorflow.TensorProto.int64_val)
|
|
return int64_val_.Get(index);
|
|
}
|
|
void TensorProto::set_int64_val(int index, ::google::protobuf::int64 value) {
|
|
int64_val_.Set(index, value);
|
|
// @@protoc_insertion_point(field_set:tensorflow.TensorProto.int64_val)
|
|
}
|
|
void TensorProto::add_int64_val(::google::protobuf::int64 value) {
|
|
int64_val_.Add(value);
|
|
// @@protoc_insertion_point(field_add:tensorflow.TensorProto.int64_val)
|
|
}
|
|
const ::google::protobuf::RepeatedField< ::google::protobuf::int64 >&
|
|
TensorProto::int64_val() const {
|
|
// @@protoc_insertion_point(field_list:tensorflow.TensorProto.int64_val)
|
|
return int64_val_;
|
|
}
|
|
::google::protobuf::RepeatedField< ::google::protobuf::int64 >*
|
|
TensorProto::mutable_int64_val() {
|
|
// @@protoc_insertion_point(field_mutable_list:tensorflow.TensorProto.int64_val)
|
|
return &int64_val_;
|
|
}
|
|
|
|
// repeated bool bool_val = 11 [packed = true];
|
|
int TensorProto::bool_val_size() const {
|
|
return bool_val_.size();
|
|
}
|
|
void TensorProto::clear_bool_val() {
|
|
bool_val_.Clear();
|
|
}
|
|
bool TensorProto::bool_val(int index) const {
|
|
// @@protoc_insertion_point(field_get:tensorflow.TensorProto.bool_val)
|
|
return bool_val_.Get(index);
|
|
}
|
|
void TensorProto::set_bool_val(int index, bool value) {
|
|
bool_val_.Set(index, value);
|
|
// @@protoc_insertion_point(field_set:tensorflow.TensorProto.bool_val)
|
|
}
|
|
void TensorProto::add_bool_val(bool value) {
|
|
bool_val_.Add(value);
|
|
// @@protoc_insertion_point(field_add:tensorflow.TensorProto.bool_val)
|
|
}
|
|
const ::google::protobuf::RepeatedField< bool >&
|
|
TensorProto::bool_val() const {
|
|
// @@protoc_insertion_point(field_list:tensorflow.TensorProto.bool_val)
|
|
return bool_val_;
|
|
}
|
|
::google::protobuf::RepeatedField< bool >*
|
|
TensorProto::mutable_bool_val() {
|
|
// @@protoc_insertion_point(field_mutable_list:tensorflow.TensorProto.bool_val)
|
|
return &bool_val_;
|
|
}
|
|
|
|
// repeated double dcomplex_val = 12 [packed = true];
|
|
int TensorProto::dcomplex_val_size() const {
|
|
return dcomplex_val_.size();
|
|
}
|
|
void TensorProto::clear_dcomplex_val() {
|
|
dcomplex_val_.Clear();
|
|
}
|
|
double TensorProto::dcomplex_val(int index) const {
|
|
// @@protoc_insertion_point(field_get:tensorflow.TensorProto.dcomplex_val)
|
|
return dcomplex_val_.Get(index);
|
|
}
|
|
void TensorProto::set_dcomplex_val(int index, double value) {
|
|
dcomplex_val_.Set(index, value);
|
|
// @@protoc_insertion_point(field_set:tensorflow.TensorProto.dcomplex_val)
|
|
}
|
|
void TensorProto::add_dcomplex_val(double value) {
|
|
dcomplex_val_.Add(value);
|
|
// @@protoc_insertion_point(field_add:tensorflow.TensorProto.dcomplex_val)
|
|
}
|
|
const ::google::protobuf::RepeatedField< double >&
|
|
TensorProto::dcomplex_val() const {
|
|
// @@protoc_insertion_point(field_list:tensorflow.TensorProto.dcomplex_val)
|
|
return dcomplex_val_;
|
|
}
|
|
::google::protobuf::RepeatedField< double >*
|
|
TensorProto::mutable_dcomplex_val() {
|
|
// @@protoc_insertion_point(field_mutable_list:tensorflow.TensorProto.dcomplex_val)
|
|
return &dcomplex_val_;
|
|
}
|
|
|
|
inline const TensorProto* TensorProto::internal_default_instance() {
|
|
return &TensorProto_default_instance_.get();
|
|
}
|
|
#endif // PROTOBUF_INLINE_NOT_IN_HEADERS
|
|
|
|
// @@protoc_insertion_point(namespace_scope)
|
|
|
|
} // namespace tensorflow
|
|
|
|
// @@protoc_insertion_point(global_scope)
|