提交 cec61f3d 编写于 作者: L liuruilong

remove third-party folder

上级 8a3a01ee
...@@ -27,29 +27,12 @@ include_directories(src/) ...@@ -27,29 +27,12 @@ include_directories(src/)
# INSTALL_COMMAND "make" "PREFIX=${CMAKE_BINARY_DIR}/" "install" # INSTALL_COMMAND "make" "PREFIX=${CMAKE_BINARY_DIR}/" "install"
# ) # )
#set_target_properties(openblas_proj PROPERTIES EXCLUDE_FROM_ALL 1) #set_target_properties(openblas_proj PROPERTIES EXCLUDE_FROM_ALL 1)
# link protobuf
include_directories(third-party/protobuf/include)
include_directories(third-party/protobuf-c-decoder/include)
if (ANDROID)
link_directories(third-party/protobuf/armeabi-v7a)
else()
# link openblas
link_directories(third-party/protobuf/lib)
link_directories(third-party/protobuf-c-decoder/lib)
endif ()
#add_dependencies(paddle-mobile openblas_proj) #add_dependencies(paddle-mobile openblas_proj)
# gen static # gen static
ADD_LIBRARY(paddle-mobile SHARED ${PADDLE_MOBILE_CC} ${PADDLE_MOBILE_H}) ADD_LIBRARY(paddle-mobile SHARED ${PADDLE_MOBILE_CC} ${PADDLE_MOBILE_H})
if (ANDROID)
# openblas.a need log lib
target_link_libraries(paddle-mobile protobuf-lite)
else()
target_link_libraries(paddle-mobile protobuf-lite)
target_link_libraries(paddle-mobile protobuf-c-decoder)
endif ()
#add_dependencies(paddle-mobile openblas_proj) #add_dependencies(paddle-mobile openblas_proj)
add_subdirectory(test) add_subdirectory(test)
/*
* Copyright (c) 2008-2015, Dave Benson and the protobuf-c authors.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following disclaimer
* in the documentation and/or other materials provided with the
* distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/*! \file
* Support library for `protoc-c` generated code.
*
* This file implements the public API used by the code generated
* by `protoc-c`.
*
* \authors Dave Benson and the protobuf-c authors
*
* \copyright 2008-2014. Licensed under the terms of the [BSD-2-Clause] license.
*/
/**
* \todo 64-BIT OPTIMIZATION: certain implementations use 32-bit math
* even on 64-bit platforms (uint64_size, uint64_pack, parse_uint64).
*
* \todo Use size_t consistently.
*/
#include <stdlib.h> /* for malloc, free */
#include <string.h> /* for strcmp, strlen, memcpy, memmove, memset */
#include "protobuf-c.h"
#define TRUE 1
#define FALSE 0
#define PROTOBUF_C__ASSERT_NOT_REACHED() assert(0)
/* Workaround for Microsoft compilers. */
#ifdef _MSC_VER
# define inline __inline
#endif
/**
* \defgroup internal Internal functions and macros
*
* These are not exported by the library but are useful to developers working
* on `libprotobuf-c` itself.
*/
/**
* \defgroup macros Utility macros for manipulating structures
*
* Macros and constants used to manipulate the base "classes" generated by
* `protobuf-c`. They also define limits and check correctness.
*
* \ingroup internal
* @{
*/
/** The maximum length of a 64-bit integer in varint encoding. */
#define MAX_UINT64_ENCODED_SIZE 10
#ifndef PROTOBUF_C_UNPACK_ERROR
# define PROTOBUF_C_UNPACK_ERROR(...)
#endif
const char protobuf_c_empty_string[] = "";
/**
* Internal `ProtobufCMessage` manipulation macro.
*
* Base macro for manipulating a `ProtobufCMessage`. Used by STRUCT_MEMBER() and
* STRUCT_MEMBER_PTR().
*/
#define STRUCT_MEMBER_P(struct_p, struct_offset) \
((void *) ((uint8_t *) (struct_p) + (struct_offset)))
/**
* Return field in a `ProtobufCMessage` based on offset.
*
* Take a pointer to a `ProtobufCMessage` and find the field at the offset.
* Cast it to the passed type.
*/
#define STRUCT_MEMBER(member_type, struct_p, struct_offset) \
(*(member_type *) STRUCT_MEMBER_P((struct_p), (struct_offset)))
/**
* Return field in a `ProtobufCMessage` based on offset.
*
* Take a pointer to a `ProtobufCMessage` and find the field at the offset. Cast
* it to a pointer to the passed type.
*/
#define STRUCT_MEMBER_PTR(member_type, struct_p, struct_offset) \
((member_type *) STRUCT_MEMBER_P((struct_p), (struct_offset)))
/* Assertions for magic numbers. */
#define ASSERT_IS_ENUM_DESCRIPTOR(desc) \
assert((desc)->magic == PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC)
#define ASSERT_IS_MESSAGE_DESCRIPTOR(desc) \
assert((desc)->magic == PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC)
#define ASSERT_IS_MESSAGE(message) \
ASSERT_IS_MESSAGE_DESCRIPTOR((message)->descriptor)
#define ASSERT_IS_SERVICE_DESCRIPTOR(desc) \
assert((desc)->magic == PROTOBUF_C__SERVICE_DESCRIPTOR_MAGIC)
/**@}*/
/* --- version --- */
const char *
protobuf_c_version(void)
{
return PROTOBUF_C_VERSION;
}
uint32_t
protobuf_c_version_number(void)
{
return PROTOBUF_C_VERSION_NUMBER;
}
/* --- allocator --- */
static void *
system_alloc(void *allocator_data, size_t size)
{
return malloc(size);
}
static void
system_free(void *allocator_data, void *data)
{
free(data);
}
static inline void *
do_alloc(ProtobufCAllocator *allocator, size_t size)
{
return allocator->alloc(allocator->allocator_data, size);
}
static inline void
do_free(ProtobufCAllocator *allocator, void *data)
{
if (data != NULL)
allocator->free(allocator->allocator_data, data);
}
/*
* This allocator uses the system's malloc() and free(). It is the default
* allocator used if NULL is passed as the ProtobufCAllocator to an exported
* function.
*/
static ProtobufCAllocator protobuf_c__allocator = {
.alloc = &system_alloc,
.free = &system_free,
.allocator_data = NULL,
};
/* === buffer-simple === */
void
protobuf_c_buffer_simple_append(ProtobufCBuffer *buffer,
size_t len, const uint8_t *data)
{
ProtobufCBufferSimple *simp = (ProtobufCBufferSimple *) buffer;
size_t new_len = simp->len + len;
if (new_len > simp->alloced) {
ProtobufCAllocator *allocator = simp->allocator;
size_t new_alloced = simp->alloced * 2;
uint8_t *new_data;
if (allocator == NULL)
allocator = &protobuf_c__allocator;
while (new_alloced < new_len)
new_alloced += new_alloced;
new_data = do_alloc(allocator, new_alloced);
if (!new_data)
return;
memcpy(new_data, simp->data, simp->len);
if (simp->must_free_data)
do_free(allocator, simp->data);
else
simp->must_free_data = TRUE;
simp->data = new_data;
simp->alloced = new_alloced;
}
memcpy(simp->data + simp->len, data, len);
simp->len = new_len;
}
/**
* \defgroup packedsz protobuf_c_message_get_packed_size() implementation
*
* Routines mainly used by protobuf_c_message_get_packed_size().
*
* \ingroup internal
* @{
*/
/**
* Return the number of bytes required to store the tag for the field. Includes
* 3 bits for the wire-type, and a single bit that denotes the end-of-tag.
*
* \param number
* Field tag to encode.
* \return
* Number of bytes required.
*/
static inline size_t
get_tag_size(uint32_t number)
{
if (number < (1UL << 4)) {
return 1;
} else if (number < (1UL << 11)) {
return 2;
} else if (number < (1UL << 18)) {
return 3;
} else if (number < (1UL << 25)) {
return 4;
} else {
return 5;
}
}
/**
* Return the number of bytes required to store a variable-length unsigned
* 32-bit integer in base-128 varint encoding.
*
* \param v
* Value to encode.
* \return
* Number of bytes required.
*/
static inline size_t
uint32_size(uint32_t v)
{
if (v < (1UL << 7)) {
return 1;
} else if (v < (1UL << 14)) {
return 2;
} else if (v < (1UL << 21)) {
return 3;
} else if (v < (1UL << 28)) {
return 4;
} else {
return 5;
}
}
/**
* Return the number of bytes required to store a variable-length signed 32-bit
* integer in base-128 varint encoding.
*
* \param v
* Value to encode.
* \return
* Number of bytes required.
*/
static inline size_t
int32_size(int32_t v)
{
if (v < 0) {
return 10;
} else if (v < (1L << 7)) {
return 1;
} else if (v < (1L << 14)) {
return 2;
} else if (v < (1L << 21)) {
return 3;
} else if (v < (1L << 28)) {
return 4;
} else {
return 5;
}
}
/**
* Return the ZigZag-encoded 32-bit unsigned integer form of a 32-bit signed
* integer.
*
* \param v
* Value to encode.
* \return
* ZigZag encoded integer.
*/
static inline uint32_t
zigzag32(int32_t v)
{
if (v < 0)
return (-(uint32_t)v) * 2 - 1;
else
return (uint32_t)(v) * 2;
}
/**
* Return the number of bytes required to store a signed 32-bit integer,
* converted to an unsigned 32-bit integer with ZigZag encoding, using base-128
* varint encoding.
*
* \param v
* Value to encode.
* \return
* Number of bytes required.
*/
static inline size_t
sint32_size(int32_t v)
{
return uint32_size(zigzag32(v));
}
/**
* Return the number of bytes required to store a 64-bit unsigned integer in
* base-128 varint encoding.
*
* \param v
* Value to encode.
* \return
* Number of bytes required.
*/
static inline size_t
uint64_size(uint64_t v)
{
uint32_t upper_v = (uint32_t) (v >> 32);
if (upper_v == 0) {
return uint32_size((uint32_t) v);
} else if (upper_v < (1UL << 3)) {
return 5;
} else if (upper_v < (1UL << 10)) {
return 6;
} else if (upper_v < (1UL << 17)) {
return 7;
} else if (upper_v < (1UL << 24)) {
return 8;
} else if (upper_v < (1UL << 31)) {
return 9;
} else {
return 10;
}
}
/**
* Return the ZigZag-encoded 64-bit unsigned integer form of a 64-bit signed
* integer.
*
* \param v
* Value to encode.
* \return
* ZigZag encoded integer.
*/
static inline uint64_t
zigzag64(int64_t v)
{
if (v < 0)
return (-(uint64_t)v) * 2 - 1;
else
return (uint64_t)(v) * 2;
}
/**
* Return the number of bytes required to store a signed 64-bit integer,
* converted to an unsigned 64-bit integer with ZigZag encoding, using base-128
* varint encoding.
*
* \param v
* Value to encode.
* \return
* Number of bytes required.
*/
static inline size_t
sint64_size(int64_t v)
{
return uint64_size(zigzag64(v));
}
/**
* Calculate the serialized size of a single required message field, including
* the space needed by the preceding tag.
*
* \param field
* Field descriptor for member.
* \param member
* Field to encode.
* \return
* Number of bytes required.
*/
static size_t
required_field_get_packed_size(const ProtobufCFieldDescriptor *field,
const void *member)
{
size_t rv = get_tag_size(field->id);
switch (field->type) {
case PROTOBUF_C_TYPE_SINT32:
return rv + sint32_size(*(const int32_t *) member);
case PROTOBUF_C_TYPE_ENUM:
case PROTOBUF_C_TYPE_INT32:
return rv + int32_size(*(const int32_t *) member);
case PROTOBUF_C_TYPE_UINT32:
return rv + uint32_size(*(const uint32_t *) member);
case PROTOBUF_C_TYPE_SINT64:
return rv + sint64_size(*(const int64_t *) member);
case PROTOBUF_C_TYPE_INT64:
case PROTOBUF_C_TYPE_UINT64:
return rv + uint64_size(*(const uint64_t *) member);
case PROTOBUF_C_TYPE_SFIXED32:
case PROTOBUF_C_TYPE_FIXED32:
return rv + 4;
case PROTOBUF_C_TYPE_SFIXED64:
case PROTOBUF_C_TYPE_FIXED64:
return rv + 8;
case PROTOBUF_C_TYPE_BOOL:
return rv + 1;
case PROTOBUF_C_TYPE_FLOAT:
return rv + 4;
case PROTOBUF_C_TYPE_DOUBLE:
return rv + 8;
case PROTOBUF_C_TYPE_STRING: {
const char *str = *(char * const *) member;
size_t len = str ? strlen(str) : 0;
return rv + uint32_size(len) + len;
}
case PROTOBUF_C_TYPE_BYTES: {
size_t len = ((const ProtobufCBinaryData *) member)->len;
return rv + uint32_size(len) + len;
}
case PROTOBUF_C_TYPE_MESSAGE: {
const ProtobufCMessage *msg = *(ProtobufCMessage * const *) member;
size_t subrv = msg ? protobuf_c_message_get_packed_size(msg) : 0;
return rv + uint32_size(subrv) + subrv;
}
}
PROTOBUF_C__ASSERT_NOT_REACHED();
return 0;
}
/**
* Calculate the serialized size of a single oneof message field, including
* the space needed by the preceding tag. Returns 0 if the oneof field isn't
* selected or is not set.
*
* \param field
* Field descriptor for member.
* \param oneof_case
* Enum value that selects the field in the oneof.
* \param member
* Field to encode.
* \return
* Number of bytes required.
*/
static size_t
oneof_field_get_packed_size(const ProtobufCFieldDescriptor *field,
uint32_t oneof_case,
const void *member)
{
if (oneof_case != field->id) {
return 0;
}
if (field->type == PROTOBUF_C_TYPE_MESSAGE ||
field->type == PROTOBUF_C_TYPE_STRING)
{
const void *ptr = *(const void * const *) member;
if (ptr == NULL || ptr == field->default_value)
return 0;
}
return required_field_get_packed_size(field, member);
}
/**
* Calculate the serialized size of a single optional message field, including
* the space needed by the preceding tag. Returns 0 if the optional field isn't
* set.
*
* \param field
* Field descriptor for member.
* \param has
* True if the field exists, false if not.
* \param member
* Field to encode.
* \return
* Number of bytes required.
*/
static size_t
optional_field_get_packed_size(const ProtobufCFieldDescriptor *field,
const protobuf_c_boolean has,
const void *member)
{
if (field->type == PROTOBUF_C_TYPE_MESSAGE ||
field->type == PROTOBUF_C_TYPE_STRING)
{
const void *ptr = *(const void * const *) member;
if (ptr == NULL || ptr == field->default_value)
return 0;
} else {
if (!has)
return 0;
}
return required_field_get_packed_size(field, member);
}
static protobuf_c_boolean
field_is_zeroish(const ProtobufCFieldDescriptor *field,
const void *member)
{
protobuf_c_boolean ret = FALSE;
switch (field->type) {
case PROTOBUF_C_TYPE_BOOL:
ret = (0 == *(const protobuf_c_boolean *) member);
break;
case PROTOBUF_C_TYPE_ENUM:
case PROTOBUF_C_TYPE_SINT32:
case PROTOBUF_C_TYPE_INT32:
case PROTOBUF_C_TYPE_UINT32:
case PROTOBUF_C_TYPE_SFIXED32:
case PROTOBUF_C_TYPE_FIXED32:
ret = (0 == *(const uint32_t *) member);
break;
case PROTOBUF_C_TYPE_SINT64:
case PROTOBUF_C_TYPE_INT64:
case PROTOBUF_C_TYPE_UINT64:
case PROTOBUF_C_TYPE_SFIXED64:
case PROTOBUF_C_TYPE_FIXED64:
ret = (0 == *(const uint64_t *) member);
break;
case PROTOBUF_C_TYPE_FLOAT:
ret = (0 == *(const float *) member);
break;
case PROTOBUF_C_TYPE_DOUBLE:
ret = (0 == *(const double *) member);
break;
case PROTOBUF_C_TYPE_STRING:
ret = (NULL == *(const char * const *) member) ||
('\0' == **(const char * const *) member);
break;
case PROTOBUF_C_TYPE_BYTES:
case PROTOBUF_C_TYPE_MESSAGE:
ret = (NULL == *(const void * const *) member);
break;
default:
ret = TRUE;
break;
}
return ret;
}
/**
* Calculate the serialized size of a single unlabeled message field, including
* the space needed by the preceding tag. Returns 0 if the field isn't set or
* if it is set to a "zeroish" value (null pointer or 0 for numerical values).
* Unlabeled fields are supported only in proto3.
*
* \param field
* Field descriptor for member.
* \param member
* Field to encode.
* \return
* Number of bytes required.
*/
static size_t
unlabeled_field_get_packed_size(const ProtobufCFieldDescriptor *field,
const void *member)
{
if (field_is_zeroish(field, member))
return 0;
return required_field_get_packed_size(field, member);
}
/**
* Calculate the serialized size of repeated message fields, which may consist
* of any number of values (including 0). Includes the space needed by the
* preceding tags (as needed).
*
* \param field
* Field descriptor for member.
* \param count
* Number of repeated field members.
* \param member
* Field to encode.
* \return
* Number of bytes required.
*/
static size_t
repeated_field_get_packed_size(const ProtobufCFieldDescriptor *field,
size_t count, const void *member)
{
size_t header_size;
size_t rv = 0;
unsigned i;
void *array = *(void * const *) member;
if (count == 0)
return 0;
header_size = get_tag_size(field->id);
if (0 == (field->flags & PROTOBUF_C_FIELD_FLAG_PACKED))
header_size *= count;
switch (field->type) {
case PROTOBUF_C_TYPE_SINT32:
for (i = 0; i < count; i++)
rv += sint32_size(((int32_t *) array)[i]);
break;
case PROTOBUF_C_TYPE_ENUM:
case PROTOBUF_C_TYPE_INT32:
for (i = 0; i < count; i++)
rv += int32_size(((int32_t *) array)[i]);
break;
case PROTOBUF_C_TYPE_UINT32:
for (i = 0; i < count; i++)
rv += uint32_size(((uint32_t *) array)[i]);
break;
case PROTOBUF_C_TYPE_SINT64:
for (i = 0; i < count; i++)
rv += sint64_size(((int64_t *) array)[i]);
break;
case PROTOBUF_C_TYPE_INT64:
case PROTOBUF_C_TYPE_UINT64:
for (i = 0; i < count; i++)
rv += uint64_size(((uint64_t *) array)[i]);
break;
case PROTOBUF_C_TYPE_SFIXED32:
case PROTOBUF_C_TYPE_FIXED32:
case PROTOBUF_C_TYPE_FLOAT:
rv += 4 * count;
break;
case PROTOBUF_C_TYPE_SFIXED64:
case PROTOBUF_C_TYPE_FIXED64:
case PROTOBUF_C_TYPE_DOUBLE:
rv += 8 * count;
break;
case PROTOBUF_C_TYPE_BOOL:
rv += count;
break;
case PROTOBUF_C_TYPE_STRING:
for (i = 0; i < count; i++) {
size_t len = strlen(((char **) array)[i]);
rv += uint32_size(len) + len;
}
break;
case PROTOBUF_C_TYPE_BYTES:
for (i = 0; i < count; i++) {
size_t len = ((ProtobufCBinaryData *) array)[i].len;
rv += uint32_size(len) + len;
}
break;
case PROTOBUF_C_TYPE_MESSAGE:
for (i = 0; i < count; i++) {
size_t len = protobuf_c_message_get_packed_size(
((ProtobufCMessage **) array)[i]);
rv += uint32_size(len) + len;
}
break;
}
if (0 != (field->flags & PROTOBUF_C_FIELD_FLAG_PACKED))
header_size += uint32_size(rv);
return header_size + rv;
}
/**
* Calculate the serialized size of an unknown field, i.e. one that is passed
* through mostly uninterpreted. This is required for forward compatibility if
* new fields are added to the message descriptor.
*
* \param field
* Unknown field type.
* \return
* Number of bytes required.
*/
static inline size_t
unknown_field_get_packed_size(const ProtobufCMessageUnknownField *field)
{
return get_tag_size(field->tag) + field->len;
}
/**@}*/
/*
* Calculate the serialized size of the message.
*/
size_t protobuf_c_message_get_packed_size(const ProtobufCMessage *message)
{
unsigned i;
size_t rv = 0;
ASSERT_IS_MESSAGE(message);
for (i = 0; i < message->descriptor->n_fields; i++) {
const ProtobufCFieldDescriptor *field =
message->descriptor->fields + i;
const void *member =
((const char *) message) + field->offset;
const void *qmember =
((const char *) message) + field->quantifier_offset;
if (field->label == PROTOBUF_C_LABEL_REQUIRED) {
rv += required_field_get_packed_size(field, member);
} else if ((field->label == PROTOBUF_C_LABEL_OPTIONAL ||
field->label == PROTOBUF_C_LABEL_NONE) &&
(0 != (field->flags & PROTOBUF_C_FIELD_FLAG_ONEOF))) {
rv += oneof_field_get_packed_size(
field,
*(const uint32_t *) qmember,
member
);
} else if (field->label == PROTOBUF_C_LABEL_OPTIONAL) {
rv += optional_field_get_packed_size(
field,
*(protobuf_c_boolean *) qmember,
member
);
} else if (field->label == PROTOBUF_C_LABEL_NONE) {
rv += unlabeled_field_get_packed_size(
field,
member
);
} else {
rv += repeated_field_get_packed_size(
field,
*(const size_t *) qmember,
member
);
}
}
for (i = 0; i < message->n_unknown_fields; i++)
rv += unknown_field_get_packed_size(&message->unknown_fields[i]);
return rv;
}
/**
* \defgroup pack protobuf_c_message_pack() implementation
*
* Routines mainly used by protobuf_c_message_pack().
*
* \ingroup internal
* @{
*/
/**
* Pack an unsigned 32-bit integer in base-128 varint encoding and return the
* number of bytes written, which must be 5 or less.
*
* \param value
* Value to encode.
* \param[out] out
* Packed value.
* \return
* Number of bytes written to `out`.
*/
static inline size_t
uint32_pack(uint32_t value, uint8_t *out)
{
unsigned rv = 0;
if (value >= 0x80) {
out[rv++] = value | 0x80;
value >>= 7;
if (value >= 0x80) {
out[rv++] = value | 0x80;
value >>= 7;
if (value >= 0x80) {
out[rv++] = value | 0x80;
value >>= 7;
if (value >= 0x80) {
out[rv++] = value | 0x80;
value >>= 7;
}
}
}
}
/* assert: value<128 */
out[rv++] = value;
return rv;
}
/**
* Pack a signed 32-bit integer and return the number of bytes written.
* Negative numbers are encoded as two's complement 64-bit integers.
*
* \param value
* Value to encode.
* \param[out] out
* Packed value.
* \return
* Number of bytes written to `out`.
*/
static inline size_t
int32_pack(int32_t value, uint8_t *out)
{
if (value < 0) {
out[0] = value | 0x80;
out[1] = (value >> 7) | 0x80;
out[2] = (value >> 14) | 0x80;
out[3] = (value >> 21) | 0x80;
out[4] = (value >> 28) | 0x80;
out[5] = out[6] = out[7] = out[8] = 0xff;
out[9] = 0x01;
return 10;
} else {
return uint32_pack(value, out);
}
}
/**
* Pack a signed 32-bit integer using ZigZag encoding and return the number of
* bytes written.
*
* \param value
* Value to encode.
* \param[out] out
* Packed value.
* \return
* Number of bytes written to `out`.
*/
static inline size_t
sint32_pack(int32_t value, uint8_t *out)
{
return uint32_pack(zigzag32(value), out);
}
/**
* Pack a 64-bit unsigned integer using base-128 varint encoding and return the
* number of bytes written.
*
* \param value
* Value to encode.
* \param[out] out
* Packed value.
* \return
* Number of bytes written to `out`.
*/
static size_t
uint64_pack(uint64_t value, uint8_t *out)
{
uint32_t hi = (uint32_t) (value >> 32);
uint32_t lo = (uint32_t) value;
unsigned rv;
if (hi == 0)
return uint32_pack((uint32_t) lo, out);
out[0] = (lo) | 0x80;
out[1] = (lo >> 7) | 0x80;
out[2] = (lo >> 14) | 0x80;
out[3] = (lo >> 21) | 0x80;
if (hi < 8) {
out[4] = (hi << 4) | (lo >> 28);
return 5;
} else {
out[4] = ((hi & 7) << 4) | (lo >> 28) | 0x80;
hi >>= 3;
}
rv = 5;
while (hi >= 128) {
out[rv++] = hi | 0x80;
hi >>= 7;
}
out[rv++] = hi;
return rv;
}
/**
* Pack a 64-bit signed integer in ZigZag encoding and return the number of
* bytes written.
*
* \param value
* Value to encode.
* \param[out] out
* Packed value.
* \return
* Number of bytes written to `out`.
*/
static inline size_t
sint64_pack(int64_t value, uint8_t *out)
{
return uint64_pack(zigzag64(value), out);
}
/**
* Pack a 32-bit quantity in little-endian byte order. Used for protobuf wire
* types fixed32, sfixed32, float. Similar to "htole32".
*
* \param value
* Value to encode.
* \param[out] out
* Packed value.
* \return
* Number of bytes written to `out`.
*/
static inline size_t
fixed32_pack(uint32_t value, void *out)
{
#if !defined(WORDS_BIGENDIAN)
memcpy(out, &value, 4);
#else
uint8_t *buf = out;
buf[0] = value;
buf[1] = value >> 8;
buf[2] = value >> 16;
buf[3] = value >> 24;
#endif
return 4;
}
/**
* Pack a 64-bit quantity in little-endian byte order. Used for protobuf wire
* types fixed64, sfixed64, double. Similar to "htole64".
*
* \todo The big-endian impl is really only good for 32-bit machines, a 64-bit
* version would be appreciated, plus a way to decide to use 64-bit math where
* convenient.
*
* \param value
* Value to encode.
* \param[out] out
* Packed value.
* \return
* Number of bytes written to `out`.
*/
static inline size_t
fixed64_pack(uint64_t value, void *out)
{
#if !defined(WORDS_BIGENDIAN)
memcpy(out, &value, 8);
#else
fixed32_pack(value, out);
fixed32_pack(value >> 32, ((char *) out) + 4);
#endif
return 8;
}
/**
* Pack a boolean value as an integer and return the number of bytes written.
*
* \todo Perhaps on some platforms *out = !!value would be a better impl, b/c
* that is idiomatic C++ in some STL implementations.
*
* \param value
* Value to encode.
* \param[out] out
* Packed value.
* \return
* Number of bytes written to `out`.
*/
static inline size_t
boolean_pack(protobuf_c_boolean value, uint8_t *out)
{
*out = value ? TRUE : FALSE;
return 1;
}
/**
* Pack a NUL-terminated C string and return the number of bytes written. The
* output includes a length delimiter.
*
* The NULL pointer is treated as an empty string. This isn't really necessary,
* but it allows people to leave required strings blank. (See Issue #13 in the
* bug tracker for a little more explanation).
*
* \param str
* String to encode.
* \param[out] out
* Packed value.
* \return
* Number of bytes written to `out`.
*/
static inline size_t
string_pack(const char *str, uint8_t *out)
{
if (str == NULL) {
out[0] = 0;
return 1;
} else {
size_t len = strlen(str);
size_t rv = uint32_pack(len, out);
memcpy(out + rv, str, len);
return rv + len;
}
}
/**
* Pack a ProtobufCBinaryData and return the number of bytes written. The output
* includes a length delimiter.
*
* \param bd
* ProtobufCBinaryData to encode.
* \param[out] out
* Packed value.
* \return
* Number of bytes written to `out`.
*/
static inline size_t
binary_data_pack(const ProtobufCBinaryData *bd, uint8_t *out)
{
size_t len = bd->len;
size_t rv = uint32_pack(len, out);
memcpy(out + rv, bd->data, len);
return rv + len;
}
/**
* Pack a ProtobufCMessage and return the number of bytes written. The output
* includes a length delimiter.
*
* \param message
* ProtobufCMessage object to pack.
* \param[out] out
* Packed message.
* \return
* Number of bytes written to `out`.
*/
static inline size_t
prefixed_message_pack(const ProtobufCMessage *message, uint8_t *out)
{
if (message == NULL) {
out[0] = 0;
return 1;
} else {
size_t rv = protobuf_c_message_pack(message, out + 1);
uint32_t rv_packed_size = uint32_size(rv);
if (rv_packed_size != 1)
memmove(out + rv_packed_size, out + 1, rv);
return uint32_pack(rv, out) + rv;
}
}
/**
* Pack a field tag.
*
* Wire-type will be added in required_field_pack().
*
* \todo Just call uint64_pack on 64-bit platforms.
*
* \param id
* Tag value to encode.
* \param[out] out
* Packed value.
* \return
* Number of bytes written to `out`.
*/
static size_t
tag_pack(uint32_t id, uint8_t *out)
{
if (id < (1UL << (32 - 3)))
return uint32_pack(id << 3, out);
else
return uint64_pack(((uint64_t) id) << 3, out);
}
/**
* Pack a required field and return the number of bytes written.
*
* \param field
* Field descriptor.
* \param member
* The field member.
* \param[out] out
* Packed value.
* \return
* Number of bytes written to `out`.
*/
static size_t
required_field_pack(const ProtobufCFieldDescriptor *field,
const void *member, uint8_t *out)
{
size_t rv = tag_pack(field->id, out);
switch (field->type) {
case PROTOBUF_C_TYPE_SINT32:
out[0] |= PROTOBUF_C_WIRE_TYPE_VARINT;
return rv + sint32_pack(*(const int32_t *) member, out + rv);
case PROTOBUF_C_TYPE_ENUM:
case PROTOBUF_C_TYPE_INT32:
out[0] |= PROTOBUF_C_WIRE_TYPE_VARINT;
return rv + int32_pack(*(const int32_t *) member, out + rv);
case PROTOBUF_C_TYPE_UINT32:
out[0] |= PROTOBUF_C_WIRE_TYPE_VARINT;
return rv + uint32_pack(*(const uint32_t *) member, out + rv);
case PROTOBUF_C_TYPE_SINT64:
out[0] |= PROTOBUF_C_WIRE_TYPE_VARINT;
return rv + sint64_pack(*(const int64_t *) member, out + rv);
case PROTOBUF_C_TYPE_INT64:
case PROTOBUF_C_TYPE_UINT64:
out[0] |= PROTOBUF_C_WIRE_TYPE_VARINT;
return rv + uint64_pack(*(const uint64_t *) member, out + rv);
case PROTOBUF_C_TYPE_SFIXED32:
case PROTOBUF_C_TYPE_FIXED32:
case PROTOBUF_C_TYPE_FLOAT:
out[0] |= PROTOBUF_C_WIRE_TYPE_32BIT;
return rv + fixed32_pack(*(const uint32_t *) member, out + rv);
case PROTOBUF_C_TYPE_SFIXED64:
case PROTOBUF_C_TYPE_FIXED64:
case PROTOBUF_C_TYPE_DOUBLE:
out[0] |= PROTOBUF_C_WIRE_TYPE_64BIT;
return rv + fixed64_pack(*(const uint64_t *) member, out + rv);
case PROTOBUF_C_TYPE_BOOL:
out[0] |= PROTOBUF_C_WIRE_TYPE_VARINT;
return rv + boolean_pack(*(const protobuf_c_boolean *) member, out + rv);
case PROTOBUF_C_TYPE_STRING:
out[0] |= PROTOBUF_C_WIRE_TYPE_LENGTH_PREFIXED;
return rv + string_pack(*(char *const *) member, out + rv);
case PROTOBUF_C_TYPE_BYTES:
out[0] |= PROTOBUF_C_WIRE_TYPE_LENGTH_PREFIXED;
return rv + binary_data_pack((const ProtobufCBinaryData *) member, out + rv);
case PROTOBUF_C_TYPE_MESSAGE:
out[0] |= PROTOBUF_C_WIRE_TYPE_LENGTH_PREFIXED;
return rv + prefixed_message_pack(*(ProtobufCMessage * const *) member, out + rv);
}
PROTOBUF_C__ASSERT_NOT_REACHED();
return 0;
}
/**
* Pack a oneof field and return the number of bytes written. Only packs the
* field that is selected by the case enum.
*
* \param field
* Field descriptor.
* \param oneof_case
* Enum value that selects the field in the oneof.
* \param member
* The field member.
* \param[out] out
* Packed value.
* \return
* Number of bytes written to `out`.
*/
static size_t
oneof_field_pack(const ProtobufCFieldDescriptor *field,
uint32_t oneof_case,
const void *member, uint8_t *out)
{
if (oneof_case != field->id) {
return 0;
}
if (field->type == PROTOBUF_C_TYPE_MESSAGE ||
field->type == PROTOBUF_C_TYPE_STRING)
{
const void *ptr = *(const void * const *) member;
if (ptr == NULL || ptr == field->default_value)
return 0;
}
return required_field_pack(field, member, out);
}
/**
* Pack an optional field and return the number of bytes written.
*
* \param field
* Field descriptor.
* \param has
* Whether the field is set.
* \param member
* The field member.
* \param[out] out
* Packed value.
* \return
* Number of bytes written to `out`.
*/
static size_t
optional_field_pack(const ProtobufCFieldDescriptor *field,
const protobuf_c_boolean has,
const void *member, uint8_t *out)
{
if (field->type == PROTOBUF_C_TYPE_MESSAGE ||
field->type == PROTOBUF_C_TYPE_STRING)
{
const void *ptr = *(const void * const *) member;
if (ptr == NULL || ptr == field->default_value)
return 0;
} else {
if (!has)
return 0;
}
return required_field_pack(field, member, out);
}
/**
* Pack an unlabeled field and return the number of bytes written.
*
* \param field
* Field descriptor.
* \param member
* The field member.
* \param[out] out
* Packed value.
* \return
* Number of bytes written to `out`.
*/
static size_t
unlabeled_field_pack(const ProtobufCFieldDescriptor *field,
const void *member, uint8_t *out)
{
if (field_is_zeroish(field, member))
return 0;
return required_field_pack(field, member, out);
}
/**
* Given a field type, return the in-memory size.
*
* \todo Implement as a table lookup.
*
* \param type
* Field type.
* \return
* Size of the field.
*/
static inline size_t
sizeof_elt_in_repeated_array(ProtobufCType type)
{
switch (type) {
case PROTOBUF_C_TYPE_SINT32:
case PROTOBUF_C_TYPE_INT32:
case PROTOBUF_C_TYPE_UINT32:
case PROTOBUF_C_TYPE_SFIXED32:
case PROTOBUF_C_TYPE_FIXED32:
case PROTOBUF_C_TYPE_FLOAT:
case PROTOBUF_C_TYPE_ENUM:
return 4;
case PROTOBUF_C_TYPE_SINT64:
case PROTOBUF_C_TYPE_INT64:
case PROTOBUF_C_TYPE_UINT64:
case PROTOBUF_C_TYPE_SFIXED64:
case PROTOBUF_C_TYPE_FIXED64:
case PROTOBUF_C_TYPE_DOUBLE:
return 8;
case PROTOBUF_C_TYPE_BOOL:
return sizeof(protobuf_c_boolean);
case PROTOBUF_C_TYPE_STRING:
case PROTOBUF_C_TYPE_MESSAGE:
return sizeof(void *);
case PROTOBUF_C_TYPE_BYTES:
return sizeof(ProtobufCBinaryData);
}
PROTOBUF_C__ASSERT_NOT_REACHED();
return 0;
}
/**
* Pack an array of 32-bit quantities.
*
* \param[out] out
* Destination.
* \param[in] in
* Source.
* \param[in] n
* Number of elements in the source array.
*/
static void
copy_to_little_endian_32(void *out, const void *in, const unsigned n)
{
#if !defined(WORDS_BIGENDIAN)
memcpy(out, in, n * 4);
#else
unsigned i;
const uint32_t *ini = in;
for (i = 0; i < n; i++)
fixed32_pack(ini[i], (uint32_t *) out + i);
#endif
}
/**
* Pack an array of 64-bit quantities.
*
* \param[out] out
* Destination.
* \param[in] in
* Source.
* \param[in] n
* Number of elements in the source array.
*/
static void
copy_to_little_endian_64(void *out, const void *in, const unsigned n)
{
#if !defined(WORDS_BIGENDIAN)
memcpy(out, in, n * 8);
#else
unsigned i;
const uint64_t *ini = in;
for (i = 0; i < n; i++)
fixed64_pack(ini[i], (uint64_t *) out + i);
#endif
}
/**
* Get the minimum number of bytes required to pack a field value of a
* particular type.
*
* \param type
* Field type.
* \return
* Number of bytes.
*/
static unsigned
get_type_min_size(ProtobufCType type)
{
if (type == PROTOBUF_C_TYPE_SFIXED32 ||
type == PROTOBUF_C_TYPE_FIXED32 ||
type == PROTOBUF_C_TYPE_FLOAT)
{
return 4;
}
if (type == PROTOBUF_C_TYPE_SFIXED64 ||
type == PROTOBUF_C_TYPE_FIXED64 ||
type == PROTOBUF_C_TYPE_DOUBLE)
{
return 8;
}
return 1;
}
/**
* Get the packed size of an array of same field type.
*
* \param field
* Field descriptor.
* \param count
* Number of elements of this type.
* \param array
* The elements to get the size of.
* \return
* Number of bytes required.
*/
static size_t
get_packed_payload_length(const ProtobufCFieldDescriptor *field,
unsigned count, const void *array)
{
unsigned rv = 0;
unsigned i;
switch (field->type) {
case PROTOBUF_C_TYPE_SFIXED32:
case PROTOBUF_C_TYPE_FIXED32:
case PROTOBUF_C_TYPE_FLOAT:
return count * 4;
case PROTOBUF_C_TYPE_SFIXED64:
case PROTOBUF_C_TYPE_FIXED64:
case PROTOBUF_C_TYPE_DOUBLE:
return count * 8;
case PROTOBUF_C_TYPE_ENUM:
case PROTOBUF_C_TYPE_INT32: {
const int32_t *arr = (const int32_t *) array;
for (i = 0; i < count; i++)
rv += int32_size(arr[i]);
break;
}
case PROTOBUF_C_TYPE_SINT32: {
const int32_t *arr = (const int32_t *) array;
for (i = 0; i < count; i++)
rv += sint32_size(arr[i]);
break;
}
case PROTOBUF_C_TYPE_UINT32: {
const uint32_t *arr = (const uint32_t *) array;
for (i = 0; i < count; i++)
rv += uint32_size(arr[i]);
break;
}
case PROTOBUF_C_TYPE_SINT64: {
const int64_t *arr = (const int64_t *) array;
for (i = 0; i < count; i++)
rv += sint64_size(arr[i]);
break;
}
case PROTOBUF_C_TYPE_INT64:
case PROTOBUF_C_TYPE_UINT64: {
const uint64_t *arr = (const uint64_t *) array;
for (i = 0; i < count; i++)
rv += uint64_size(arr[i]);
break;
}
case PROTOBUF_C_TYPE_BOOL:
return count;
default:
PROTOBUF_C__ASSERT_NOT_REACHED();
}
return rv;
}
/**
* Pack an array of same field type to a virtual buffer.
*
* \param field
* Field descriptor.
* \param count
* Number of elements of this type.
* \param array
* The elements to get the size of.
* \param[out] buffer
* Virtual buffer to append data to.
* \return
* Number of bytes packed.
*/
static size_t
pack_buffer_packed_payload(const ProtobufCFieldDescriptor *field,
unsigned count, const void *array,
ProtobufCBuffer *buffer)
{
uint8_t scratch[16];
size_t rv = 0;
unsigned i;
switch (field->type) {
case PROTOBUF_C_TYPE_SFIXED32:
case PROTOBUF_C_TYPE_FIXED32:
case PROTOBUF_C_TYPE_FLOAT:
#if !defined(WORDS_BIGENDIAN)
rv = count * 4;
goto no_packing_needed;
#else
for (i = 0; i < count; i++) {
unsigned len = fixed32_pack(((uint32_t *) array)[i], scratch);
buffer->append(buffer, len, scratch);
rv += len;
}
break;
#endif
case PROTOBUF_C_TYPE_SFIXED64:
case PROTOBUF_C_TYPE_FIXED64:
case PROTOBUF_C_TYPE_DOUBLE:
#if !defined(WORDS_BIGENDIAN)
rv = count * 8;
goto no_packing_needed;
#else
for (i = 0; i < count; i++) {
unsigned len = fixed64_pack(((uint64_t *) array)[i], scratch);
buffer->append(buffer, len, scratch);
rv += len;
}
break;
#endif
case PROTOBUF_C_TYPE_ENUM:
case PROTOBUF_C_TYPE_INT32:
for (i = 0; i < count; i++) {
unsigned len = int32_pack(((int32_t *) array)[i], scratch);
buffer->append(buffer, len, scratch);
rv += len;
}
break;
case PROTOBUF_C_TYPE_SINT32:
for (i = 0; i < count; i++) {
unsigned len = sint32_pack(((int32_t *) array)[i], scratch);
buffer->append(buffer, len, scratch);
rv += len;
}
break;
case PROTOBUF_C_TYPE_UINT32:
for (i = 0; i < count; i++) {
unsigned len = uint32_pack(((uint32_t *) array)[i], scratch);
buffer->append(buffer, len, scratch);
rv += len;
}
break;
case PROTOBUF_C_TYPE_SINT64:
for (i = 0; i < count; i++) {
unsigned len = sint64_pack(((int64_t *) array)[i], scratch);
buffer->append(buffer, len, scratch);
rv += len;
}
break;
case PROTOBUF_C_TYPE_INT64:
case PROTOBUF_C_TYPE_UINT64:
for (i = 0; i < count; i++) {
unsigned len = uint64_pack(((uint64_t *) array)[i], scratch);
buffer->append(buffer, len, scratch);
rv += len;
}
break;
case PROTOBUF_C_TYPE_BOOL:
for (i = 0; i < count; i++) {
unsigned len = boolean_pack(((protobuf_c_boolean *) array)[i], scratch);
buffer->append(buffer, len, scratch);
rv += len;
}
return count;
default:
PROTOBUF_C__ASSERT_NOT_REACHED();
}
return rv;
#if !defined(WORDS_BIGENDIAN)
no_packing_needed:
buffer->append(buffer, rv, array);
return rv;
#endif
}
static inline int
int_range_lookup(unsigned n_ranges, const ProtobufCIntRange *ranges, int value)
{
unsigned n;
unsigned start;
if (n_ranges == 0)
return -1;
start = 0;
n = n_ranges;
while (n > 1) {
unsigned mid = start + n / 2;
if (value < ranges[mid].start_value) {
n = mid - start;
} else if (value >= ranges[mid].start_value +
(int) (ranges[mid + 1].orig_index -
ranges[mid].orig_index))
{
unsigned new_start = mid + 1;
n = start + n - new_start;
start = new_start;
} else
return (value - ranges[mid].start_value) +
ranges[mid].orig_index;
}
if (n > 0) {
unsigned start_orig_index = ranges[start].orig_index;
unsigned range_size =
ranges[start + 1].orig_index - start_orig_index;
if (ranges[start].start_value <= value &&
value < (int) (ranges[start].start_value + range_size))
{
return (value - ranges[start].start_value) +
start_orig_index;
}
}
return -1;
}
static size_t
parse_tag_and_wiretype(size_t len,
const uint8_t *data,
uint32_t *tag_out,
ProtobufCWireType *wiretype_out)
{
unsigned max_rv = len > 5 ? 5 : len;
uint32_t tag = (data[0] & 0x7f) >> 3;
unsigned shift = 4;
unsigned rv;
*wiretype_out = data[0] & 7;
if ((data[0] & 0x80) == 0) {
*tag_out = tag;
return 1;
}
for (rv = 1; rv < max_rv; rv++) {
if (data[rv] & 0x80) {
tag |= (data[rv] & 0x7f) << shift;
shift += 7;
} else {
tag |= data[rv] << shift;
*tag_out = tag;
return rv + 1;
}
}
return 0; /* error: bad header */
}
/* sizeof(ScannedMember) must be <= (1UL<<BOUND_SIZEOF_SCANNED_MEMBER_LOG2) */
#define BOUND_SIZEOF_SCANNED_MEMBER_LOG2 5
typedef struct _ScannedMember ScannedMember;
/** Field as it's being read. */
struct _ScannedMember {
uint32_t tag; /**< Field tag. */
uint8_t wire_type; /**< Field type. */
uint8_t length_prefix_len; /**< Prefix length. */
const ProtobufCFieldDescriptor *field; /**< Field descriptor. */
size_t len; /**< Field length. */
const uint8_t *data; /**< Pointer to field data. */
};
static inline uint32_t
scan_length_prefixed_data(size_t len, const uint8_t *data,
size_t *prefix_len_out)
{
unsigned hdr_max = len < 5 ? len : 5;
unsigned hdr_len;
uint32_t val = 0;
unsigned i;
unsigned shift = 0;
for (i = 0; i < hdr_max; i++) {
val |= (data[i] & 0x7f) << shift;
shift += 7;
if ((data[i] & 0x80) == 0)
break;
}
if (i == hdr_max) {
PROTOBUF_C_UNPACK_ERROR("error parsing length for length-prefixed data");
return 0;
}
hdr_len = i + 1;
*prefix_len_out = hdr_len;
if (hdr_len + val > len) {
PROTOBUF_C_UNPACK_ERROR("data too short after length-prefix of %u", val);
return 0;
}
return hdr_len + val;
}
static size_t
max_b128_numbers(size_t len, const uint8_t *data)
{
size_t rv = 0;
while (len--)
if ((*data++ & 0x80) == 0)
++rv;
return rv;
}
/**@}*/
/**
* Merge earlier message into a latter message.
*
* For numeric types and strings, if the same value appears multiple
* times, the parser accepts the last value it sees. For embedded
* message fields, the parser merges multiple instances of the same
* field. That is, all singular scalar fields in the latter instance
* replace those in the former, singular embedded messages are merged,
* and repeated fields are concatenated.
*
* The earlier message should be freed after calling this function, as
* some of its fields may have been reused and changed to their default
* values during the merge.
*/
static protobuf_c_boolean
merge_messages(ProtobufCMessage *earlier_msg,
ProtobufCMessage *latter_msg,
ProtobufCAllocator *allocator)
{
unsigned i;
const ProtobufCFieldDescriptor *fields =
latter_msg->descriptor->fields;
for (i = 0; i < latter_msg->descriptor->n_fields; i++) {
if (fields[i].label == PROTOBUF_C_LABEL_REPEATED) {
size_t *n_earlier =
STRUCT_MEMBER_PTR(size_t, earlier_msg,
fields[i].quantifier_offset);
uint8_t **p_earlier =
STRUCT_MEMBER_PTR(uint8_t *, earlier_msg,
fields[i].offset);
size_t *n_latter =
STRUCT_MEMBER_PTR(size_t, latter_msg,
fields[i].quantifier_offset);
uint8_t **p_latter =
STRUCT_MEMBER_PTR(uint8_t *, latter_msg,
fields[i].offset);
if (*n_earlier > 0) {
if (*n_latter > 0) {
/* Concatenate the repeated field */
size_t el_size =
sizeof_elt_in_repeated_array(fields[i].type);
uint8_t *new_field;
new_field = do_alloc(allocator,
(*n_earlier + *n_latter) * el_size);
if (!new_field)
return FALSE;
memcpy(new_field, *p_earlier,
*n_earlier * el_size);
memcpy(new_field +
*n_earlier * el_size,
*p_latter,
*n_latter * el_size);
do_free(allocator, *p_latter);
do_free(allocator, *p_earlier);
*p_latter = new_field;
*n_latter = *n_earlier + *n_latter;
} else {
/* Zero copy the repeated field from the earlier message */
*n_latter = *n_earlier;
*p_latter = *p_earlier;
}
/* Make sure the field does not get double freed */
*n_earlier = 0;
*p_earlier = 0;
}
} else if (fields[i].label == PROTOBUF_C_LABEL_OPTIONAL ||
fields[i].label == PROTOBUF_C_LABEL_NONE) {
const ProtobufCFieldDescriptor *field;
uint32_t *earlier_case_p = STRUCT_MEMBER_PTR(uint32_t,
earlier_msg,
fields[i].
quantifier_offset);
uint32_t *latter_case_p = STRUCT_MEMBER_PTR(uint32_t,
latter_msg,
fields[i].
quantifier_offset);
protobuf_c_boolean need_to_merge = FALSE;
void *earlier_elem;
void *latter_elem;
const void *def_val;
if (fields[i].flags & PROTOBUF_C_FIELD_FLAG_ONEOF) {
if (*latter_case_p == 0) {
/* lookup correct oneof field */
int field_index =
int_range_lookup(
latter_msg->descriptor
->n_field_ranges,
latter_msg->descriptor
->field_ranges,
*earlier_case_p);
field = latter_msg->descriptor->fields +
field_index;
} else {
/* Oneof is present in the latter message, move on */
continue;
}
} else {
field = &fields[i];
}
earlier_elem = STRUCT_MEMBER_P(earlier_msg, field->offset);
latter_elem = STRUCT_MEMBER_P(latter_msg, field->offset);
def_val = field->default_value;
switch (field->type) {
case PROTOBUF_C_TYPE_MESSAGE: {
ProtobufCMessage *em = *(ProtobufCMessage **) earlier_elem;
ProtobufCMessage *lm = *(ProtobufCMessage **) latter_elem;
if (em != NULL) {
if (lm != NULL) {
if (!merge_messages(em, lm, allocator))
return FALSE;
/* Already merged */
need_to_merge = FALSE;
} else {
/* Zero copy the message */
need_to_merge = TRUE;
}
}
break;
}
case PROTOBUF_C_TYPE_BYTES: {
uint8_t *e_data =
((ProtobufCBinaryData *) earlier_elem)->data;
uint8_t *l_data =
((ProtobufCBinaryData *) latter_elem)->data;
const ProtobufCBinaryData *d_bd =
(ProtobufCBinaryData *) def_val;
need_to_merge =
(e_data != NULL &&
(d_bd == NULL ||
e_data != d_bd->data)) &&
(l_data == NULL ||
(d_bd != NULL &&
l_data == d_bd->data));
break;
}
case PROTOBUF_C_TYPE_STRING: {
char *e_str = *(char **) earlier_elem;
char *l_str = *(char **) latter_elem;
const char *d_str = def_val;
need_to_merge = e_str != d_str && l_str == d_str;
break;
}
default: {
/* Could be has field or case enum, the logic is
* equivalent, since 0 (FALSE) means not set for
* oneof */
need_to_merge = (*earlier_case_p != 0) &&
(*latter_case_p == 0);
break;
}
}
if (need_to_merge) {
size_t el_size =
sizeof_elt_in_repeated_array(field->type);
memcpy(latter_elem, earlier_elem, el_size);
/*
* Reset the element from the old message to 0
* to make sure earlier message deallocation
* doesn't corrupt zero-copied data in the new
* message, earlier message will be freed after
* this function is called anyway
*/
memset(earlier_elem, 0, el_size);
if (field->quantifier_offset != 0) {
/* Set the has field or the case enum,
* if applicable */
*latter_case_p = *earlier_case_p;
*earlier_case_p = 0;
}
}
}
}
return TRUE;
}
/**
* Count packed elements.
*
* Given a raw slab of packed-repeated values, determine the number of
* elements. This function detects certain kinds of errors but not
* others; the remaining error checking is done by
* parse_packed_repeated_member().
*/
static protobuf_c_boolean
count_packed_elements(ProtobufCType type,
size_t len, const uint8_t *data, size_t *count_out)
{
switch (type) {
case PROTOBUF_C_TYPE_SFIXED32:
case PROTOBUF_C_TYPE_FIXED32:
case PROTOBUF_C_TYPE_FLOAT:
if (len % 4 != 0) {
PROTOBUF_C_UNPACK_ERROR("length must be a multiple of 4 for fixed-length 32-bit types");
return FALSE;
}
*count_out = len / 4;
return TRUE;
case PROTOBUF_C_TYPE_SFIXED64:
case PROTOBUF_C_TYPE_FIXED64:
case PROTOBUF_C_TYPE_DOUBLE:
if (len % 8 != 0) {
PROTOBUF_C_UNPACK_ERROR("length must be a multiple of 8 for fixed-length 64-bit types");
return FALSE;
}
*count_out = len / 8;
return TRUE;
case PROTOBUF_C_TYPE_ENUM:
case PROTOBUF_C_TYPE_INT32:
case PROTOBUF_C_TYPE_SINT32:
case PROTOBUF_C_TYPE_UINT32:
case PROTOBUF_C_TYPE_INT64:
case PROTOBUF_C_TYPE_SINT64:
case PROTOBUF_C_TYPE_UINT64:
*count_out = max_b128_numbers(len, data);
return TRUE;
case PROTOBUF_C_TYPE_BOOL:
*count_out = len;
return TRUE;
case PROTOBUF_C_TYPE_STRING:
case PROTOBUF_C_TYPE_BYTES:
case PROTOBUF_C_TYPE_MESSAGE:
default:
PROTOBUF_C_UNPACK_ERROR("bad protobuf-c type %u for packed-repeated", type);
return FALSE;
}
}
static inline uint32_t
parse_uint32(unsigned len, const uint8_t *data)
{
uint32_t rv = data[0] & 0x7f;
if (len > 1) {
rv |= ((uint32_t) (data[1] & 0x7f) << 7);
if (len > 2) {
rv |= ((uint32_t) (data[2] & 0x7f) << 14);
if (len > 3) {
rv |= ((uint32_t) (data[3] & 0x7f) << 21);
if (len > 4)
rv |= ((uint32_t) (data[4]) << 28);
}
}
}
return rv;
}
static inline uint32_t
parse_int32(unsigned len, const uint8_t *data)
{
return parse_uint32(len, data);
}
static inline int32_t
unzigzag32(uint32_t v)
{
if (v & 1)
return -(v >> 1) - 1;
else
return v >> 1;
}
static inline uint32_t
parse_fixed_uint32(const uint8_t *data)
{
#if !defined(WORDS_BIGENDIAN)
uint32_t t;
memcpy(&t, data, 4);
return t;
#else
return data[0] |
((uint32_t) (data[1]) << 8) |
((uint32_t) (data[2]) << 16) |
((uint32_t) (data[3]) << 24);
#endif
}
static uint64_t
parse_uint64(unsigned len, const uint8_t *data)
{
unsigned shift, i;
uint64_t rv;
if (len < 5)
return parse_uint32(len, data);
rv = ((uint64_t) (data[0] & 0x7f)) |
((uint64_t) (data[1] & 0x7f) << 7) |
((uint64_t) (data[2] & 0x7f) << 14) |
((uint64_t) (data[3] & 0x7f) << 21);
shift = 28;
for (i = 4; i < len; i++) {
rv |= (((uint64_t) (data[i] & 0x7f)) << shift);
shift += 7;
}
return rv;
}
static inline int64_t
unzigzag64(uint64_t v)
{
if (v & 1)
return -(v >> 1) - 1;
else
return v >> 1;
}
static inline uint64_t
parse_fixed_uint64(const uint8_t *data)
{
#if !defined(WORDS_BIGENDIAN)
uint64_t t;
memcpy(&t, data, 8);
return t;
#else
return (uint64_t) parse_fixed_uint32(data) |
(((uint64_t) parse_fixed_uint32(data + 4)) << 32);
#endif
}
static protobuf_c_boolean
parse_boolean(unsigned len, const uint8_t *data)
{
unsigned i;
for (i = 0; i < len; i++)
if (data[i] & 0x7f)
return TRUE;
return FALSE;
}
static protobuf_c_boolean
parse_required_member(ScannedMember *scanned_member,
void *member,
ProtobufCAllocator *allocator,
protobuf_c_boolean maybe_clear)
{
unsigned len = scanned_member->len;
const uint8_t *data = scanned_member->data;
ProtobufCWireType wire_type = scanned_member->wire_type;
switch (scanned_member->field->type) {
case PROTOBUF_C_TYPE_ENUM:
case PROTOBUF_C_TYPE_INT32:
if (wire_type != PROTOBUF_C_WIRE_TYPE_VARINT)
return FALSE;
*(int32_t *) member = parse_int32(len, data);
return TRUE;
case PROTOBUF_C_TYPE_UINT32:
if (wire_type != PROTOBUF_C_WIRE_TYPE_VARINT)
return FALSE;
*(uint32_t *) member = parse_uint32(len, data);
return TRUE;
case PROTOBUF_C_TYPE_SINT32:
if (wire_type != PROTOBUF_C_WIRE_TYPE_VARINT)
return FALSE;
*(int32_t *) member = unzigzag32(parse_uint32(len, data));
return TRUE;
case PROTOBUF_C_TYPE_SFIXED32:
case PROTOBUF_C_TYPE_FIXED32:
case PROTOBUF_C_TYPE_FLOAT:
if (wire_type != PROTOBUF_C_WIRE_TYPE_32BIT)
return FALSE;
*(uint32_t *) member = parse_fixed_uint32(data);
return TRUE;
case PROTOBUF_C_TYPE_INT64:
case PROTOBUF_C_TYPE_UINT64:
if (wire_type != PROTOBUF_C_WIRE_TYPE_VARINT)
return FALSE;
*(uint64_t *) member = parse_uint64(len, data);
return TRUE;
case PROTOBUF_C_TYPE_SINT64:
if (wire_type != PROTOBUF_C_WIRE_TYPE_VARINT)
return FALSE;
*(int64_t *) member = unzigzag64(parse_uint64(len, data));
return TRUE;
case PROTOBUF_C_TYPE_SFIXED64:
case PROTOBUF_C_TYPE_FIXED64:
case PROTOBUF_C_TYPE_DOUBLE:
if (wire_type != PROTOBUF_C_WIRE_TYPE_64BIT)
return FALSE;
*(uint64_t *) member = parse_fixed_uint64(data);
return TRUE;
case PROTOBUF_C_TYPE_BOOL:
*(protobuf_c_boolean *) member = parse_boolean(len, data);
return TRUE;
case PROTOBUF_C_TYPE_STRING: {
char **pstr = member;
unsigned pref_len = scanned_member->length_prefix_len;
if (wire_type != PROTOBUF_C_WIRE_TYPE_LENGTH_PREFIXED)
return FALSE;
if (maybe_clear && *pstr != NULL) {
const char *def = scanned_member->field->default_value;
if (*pstr != NULL && *pstr != def)
do_free(allocator, *pstr);
}
*pstr = do_alloc(allocator, len - pref_len + 1);
if (*pstr == NULL)
return FALSE;
memcpy(*pstr, data + pref_len, len - pref_len);
(*pstr)[len - pref_len] = 0;
return TRUE;
}
case PROTOBUF_C_TYPE_BYTES: {
ProtobufCBinaryData *bd = member;
const ProtobufCBinaryData *def_bd;
unsigned pref_len = scanned_member->length_prefix_len;
if (wire_type != PROTOBUF_C_WIRE_TYPE_LENGTH_PREFIXED)
return FALSE;
def_bd = scanned_member->field->default_value;
if (maybe_clear &&
bd->data != NULL &&
(def_bd == NULL || bd->data != def_bd->data))
{
do_free(allocator, bd->data);
}
if (len - pref_len > 0) {
bd->data = do_alloc(allocator, len - pref_len);
if (bd->data == NULL)
return FALSE;
memcpy(bd->data, data + pref_len, len - pref_len);
} else {
bd->data = NULL;
}
bd->len = len - pref_len;
return TRUE;
}
case PROTOBUF_C_TYPE_MESSAGE: {
ProtobufCMessage **pmessage = member;
ProtobufCMessage *subm;
const ProtobufCMessage *def_mess;
protobuf_c_boolean merge_successful = TRUE;
unsigned pref_len = scanned_member->length_prefix_len;
if (wire_type != PROTOBUF_C_WIRE_TYPE_LENGTH_PREFIXED)
return FALSE;
def_mess = scanned_member->field->default_value;
subm = protobuf_c_message_unpack(scanned_member->field->descriptor,
allocator,
len - pref_len,
data + pref_len);
if (maybe_clear &&
*pmessage != NULL &&
*pmessage != def_mess)
{
if (subm != NULL)
merge_successful = merge_messages(*pmessage, subm, allocator);
/* Delete the previous message */
protobuf_c_message_free_unpacked(*pmessage, allocator);
}
*pmessage = subm;
if (subm == NULL || !merge_successful)
return FALSE;
return TRUE;
}
}
return FALSE;
}
static protobuf_c_boolean
parse_oneof_member (ScannedMember *scanned_member,
void *member,
ProtobufCMessage *message,
ProtobufCAllocator *allocator)
{
uint32_t *oneof_case = STRUCT_MEMBER_PTR(uint32_t, message,
scanned_member->field->quantifier_offset);
/* If we have already parsed a member of this oneof, free it. */
if (*oneof_case != 0) {
/* lookup field */
int field_index =
int_range_lookup(message->descriptor->n_field_ranges,
message->descriptor->field_ranges,
*oneof_case);
const ProtobufCFieldDescriptor *old_field =
message->descriptor->fields + field_index;
size_t el_size = sizeof_elt_in_repeated_array(old_field->type);
switch (old_field->type) {
case PROTOBUF_C_TYPE_STRING: {
char **pstr = member;
const char *def = old_field->default_value;
if (*pstr != NULL && *pstr != def)
do_free(allocator, *pstr);
break;
}
case PROTOBUF_C_TYPE_BYTES: {
ProtobufCBinaryData *bd = member;
const ProtobufCBinaryData *def_bd = old_field->default_value;
if (bd->data != NULL &&
(def_bd == NULL || bd->data != def_bd->data))
{
do_free(allocator, bd->data);
}
break;
}
case PROTOBUF_C_TYPE_MESSAGE: {
ProtobufCMessage **pmessage = member;
const ProtobufCMessage *def_mess = old_field->default_value;
if (*pmessage != NULL && *pmessage != def_mess)
protobuf_c_message_free_unpacked(*pmessage, allocator);
break;
}
default:
break;
}
memset (member, 0, el_size);
}
if (!parse_required_member (scanned_member, member, allocator, TRUE))
return FALSE;
*oneof_case = scanned_member->tag;
return TRUE;
}
static protobuf_c_boolean
parse_optional_member(ScannedMember *scanned_member,
void *member,
ProtobufCMessage *message,
ProtobufCAllocator *allocator)
{
if (!parse_required_member(scanned_member, member, allocator, TRUE))
return FALSE;
if (scanned_member->field->quantifier_offset != 0)
STRUCT_MEMBER(protobuf_c_boolean,
message,
scanned_member->field->quantifier_offset) = TRUE;
return TRUE;
}
static protobuf_c_boolean
parse_repeated_member(ScannedMember *scanned_member,
void *member,
ProtobufCMessage *message,
ProtobufCAllocator *allocator)
{
const ProtobufCFieldDescriptor *field = scanned_member->field;
size_t *p_n = STRUCT_MEMBER_PTR(size_t, message, field->quantifier_offset);
size_t siz = sizeof_elt_in_repeated_array(field->type);
char *array = *(char **) member;
if (!parse_required_member(scanned_member, array + siz * (*p_n),
allocator, FALSE))
{
return FALSE;
}
*p_n += 1;
return TRUE;
}
static unsigned
scan_varint(unsigned len, const uint8_t *data)
{
unsigned i;
if (len > 10)
len = 10;
for (i = 0; i < len; i++)
if ((data[i] & 0x80) == 0)
break;
if (i == len)
return 0;
return i + 1;
}
static protobuf_c_boolean
parse_packed_repeated_member(ScannedMember *scanned_member,
void *member,
ProtobufCMessage *message)
{
const ProtobufCFieldDescriptor *field = scanned_member->field;
size_t *p_n = STRUCT_MEMBER_PTR(size_t, message, field->quantifier_offset);
size_t siz = sizeof_elt_in_repeated_array(field->type);
void *array = *(char **) member + siz * (*p_n);
const uint8_t *at = scanned_member->data + scanned_member->length_prefix_len;
size_t rem = scanned_member->len - scanned_member->length_prefix_len;
size_t count = 0;
unsigned i;
switch (field->type) {
case PROTOBUF_C_TYPE_SFIXED32:
case PROTOBUF_C_TYPE_FIXED32:
case PROTOBUF_C_TYPE_FLOAT:
count = (scanned_member->len - scanned_member->length_prefix_len) / 4;
#if !defined(WORDS_BIGENDIAN)
goto no_unpacking_needed;
#else
for (i = 0; i < count; i++) {
((uint32_t *) array)[i] = parse_fixed_uint32(at);
at += 4;
}
break;
#endif
case PROTOBUF_C_TYPE_SFIXED64:
case PROTOBUF_C_TYPE_FIXED64:
case PROTOBUF_C_TYPE_DOUBLE:
count = (scanned_member->len - scanned_member->length_prefix_len) / 8;
#if !defined(WORDS_BIGENDIAN)
goto no_unpacking_needed;
#else
for (i = 0; i < count; i++) {
((uint64_t *) array)[i] = parse_fixed_uint64(at);
at += 8;
}
break;
#endif
case PROTOBUF_C_TYPE_ENUM:
case PROTOBUF_C_TYPE_INT32:
while (rem > 0) {
unsigned s = scan_varint(rem, at);
if (s == 0) {
PROTOBUF_C_UNPACK_ERROR("bad packed-repeated int32 value");
return FALSE;
}
((int32_t *) array)[count++] = parse_int32(s, at);
at += s;
rem -= s;
}
break;
case PROTOBUF_C_TYPE_SINT32:
while (rem > 0) {
unsigned s = scan_varint(rem, at);
if (s == 0) {
PROTOBUF_C_UNPACK_ERROR("bad packed-repeated sint32 value");
return FALSE;
}
((int32_t *) array)[count++] = unzigzag32(parse_uint32(s, at));
at += s;
rem -= s;
}
break;
case PROTOBUF_C_TYPE_UINT32:
while (rem > 0) {
unsigned s = scan_varint(rem, at);
if (s == 0) {
PROTOBUF_C_UNPACK_ERROR("bad packed-repeated enum or uint32 value");
return FALSE;
}
((uint32_t *) array)[count++] = parse_uint32(s, at);
at += s;
rem -= s;
}
break;
case PROTOBUF_C_TYPE_SINT64:
while (rem > 0) {
unsigned s = scan_varint(rem, at);
if (s == 0) {
PROTOBUF_C_UNPACK_ERROR("bad packed-repeated sint64 value");
return FALSE;
}
((int64_t *) array)[count++] = unzigzag64(parse_uint64(s, at));
at += s;
rem -= s;
}
break;
case PROTOBUF_C_TYPE_INT64:
case PROTOBUF_C_TYPE_UINT64:
while (rem > 0) {
unsigned s = scan_varint(rem, at);
if (s == 0) {
PROTOBUF_C_UNPACK_ERROR("bad packed-repeated int64/uint64 value");
return FALSE;
}
((int64_t *) array)[count++] = parse_uint64(s, at);
at += s;
rem -= s;
}
break;
case PROTOBUF_C_TYPE_BOOL:
count = rem;
for (i = 0; i < count; i++) {
if (at[i] > 1) {
PROTOBUF_C_UNPACK_ERROR("bad packed-repeated boolean value");
return FALSE;
}
((protobuf_c_boolean *) array)[i] = at[i];
}
break;
default:
PROTOBUF_C__ASSERT_NOT_REACHED();
}
*p_n += count;
return TRUE;
#if !defined(WORDS_BIGENDIAN)
no_unpacking_needed:
memcpy(array, at, count * siz);
*p_n += count;
return TRUE;
#endif
}
static protobuf_c_boolean
is_packable_type(ProtobufCType type)
{
return
type != PROTOBUF_C_TYPE_STRING &&
type != PROTOBUF_C_TYPE_BYTES &&
type != PROTOBUF_C_TYPE_MESSAGE;
}
static protobuf_c_boolean
parse_member(ScannedMember *scanned_member,
ProtobufCMessage *message,
ProtobufCAllocator *allocator)
{
const ProtobufCFieldDescriptor *field = scanned_member->field;
void *member;
if (field == NULL) {
ProtobufCMessageUnknownField *ufield =
message->unknown_fields +
(message->n_unknown_fields++);
ufield->tag = scanned_member->tag;
ufield->wire_type = scanned_member->wire_type;
ufield->len = scanned_member->len;
ufield->data = do_alloc(allocator, scanned_member->len);
if (ufield->data == NULL)
return FALSE;
memcpy(ufield->data, scanned_member->data, ufield->len);
return TRUE;
}
member = (char *) message + field->offset;
switch (field->label) {
case PROTOBUF_C_LABEL_REQUIRED:
return parse_required_member(scanned_member, member,
allocator, TRUE);
case PROTOBUF_C_LABEL_OPTIONAL:
case PROTOBUF_C_LABEL_NONE:
if (0 != (field->flags & PROTOBUF_C_FIELD_FLAG_ONEOF)) {
return parse_oneof_member(scanned_member, member,
message, allocator);
} else {
return parse_optional_member(scanned_member, member,
message, allocator);
}
case PROTOBUF_C_LABEL_REPEATED:
if (scanned_member->wire_type ==
PROTOBUF_C_WIRE_TYPE_LENGTH_PREFIXED &&
(0 != (field->flags & PROTOBUF_C_FIELD_FLAG_PACKED) ||
is_packable_type(field->type)))
{
return parse_packed_repeated_member(scanned_member,
member, message);
} else {
return parse_repeated_member(scanned_member,
member, message,
allocator);
}
}
PROTOBUF_C__ASSERT_NOT_REACHED();
return 0;
}
/**
* Initialise messages generated by old code.
*
* This function is used if desc->message_init == NULL (which occurs
* for old code, and which would be useful to support allocating
* descriptors dynamically).
*/
static void
message_init_generic(const ProtobufCMessageDescriptor *desc,
ProtobufCMessage *message)
{
unsigned i;
memset(message, 0, desc->sizeof_message);
message->descriptor = desc;
for (i = 0; i < desc->n_fields; i++) {
if (desc->fields[i].default_value != NULL &&
desc->fields[i].label != PROTOBUF_C_LABEL_REPEATED)
{
void *field =
STRUCT_MEMBER_P(message, desc->fields[i].offset);
const void *dv = desc->fields[i].default_value;
switch (desc->fields[i].type) {
case PROTOBUF_C_TYPE_INT32:
case PROTOBUF_C_TYPE_SINT32:
case PROTOBUF_C_TYPE_SFIXED32:
case PROTOBUF_C_TYPE_UINT32:
case PROTOBUF_C_TYPE_FIXED32:
case PROTOBUF_C_TYPE_FLOAT:
case PROTOBUF_C_TYPE_ENUM:
memcpy(field, dv, 4);
break;
case PROTOBUF_C_TYPE_INT64:
case PROTOBUF_C_TYPE_SINT64:
case PROTOBUF_C_TYPE_SFIXED64:
case PROTOBUF_C_TYPE_UINT64:
case PROTOBUF_C_TYPE_FIXED64:
case PROTOBUF_C_TYPE_DOUBLE:
memcpy(field, dv, 8);
break;
case PROTOBUF_C_TYPE_BOOL:
memcpy(field, dv, sizeof(protobuf_c_boolean));
break;
case PROTOBUF_C_TYPE_BYTES:
memcpy(field, dv, sizeof(ProtobufCBinaryData));
break;
case PROTOBUF_C_TYPE_STRING:
case PROTOBUF_C_TYPE_MESSAGE:
/*
* The next line essentially implements a cast
* from const, which is totally unavoidable.
*/
*(const void **) field = dv;
break;
}
}
}
}
/**@}*/
/*
* ScannedMember slabs (an unpacking implementation detail). Before doing real
* unpacking, we first scan through the elements to see how many there are (for
* repeated fields), and which field to use (for non-repeated fields given
* twice).
*
* In order to avoid allocations for small messages, we keep a stack-allocated
* slab of ScannedMembers of size FIRST_SCANNED_MEMBER_SLAB_SIZE (16). After we
* fill that up, we allocate each slab twice as large as the previous one.
*/
#define FIRST_SCANNED_MEMBER_SLAB_SIZE_LOG2 4
/*
* The number of slabs, including the stack-allocated ones; choose the number so
* that we would overflow if we needed a slab larger than provided.
*/
#define MAX_SCANNED_MEMBER_SLAB \
(sizeof(unsigned int)*8 - 1 \
- BOUND_SIZEOF_SCANNED_MEMBER_LOG2 \
- FIRST_SCANNED_MEMBER_SLAB_SIZE_LOG2)
#define REQUIRED_FIELD_BITMAP_SET(index) \
(required_fields_bitmap[(index)/8] |= (1UL<<((index)%8)))
#define REQUIRED_FIELD_BITMAP_IS_SET(index) \
(required_fields_bitmap[(index)/8] & (1UL<<((index)%8)))
ProtobufCMessage *
protobuf_c_message_unpack(const ProtobufCMessageDescriptor *desc,
ProtobufCAllocator *allocator,
size_t len, const uint8_t *data)
{
ProtobufCMessage *rv;
size_t rem = len;
const uint8_t *at = data;
const ProtobufCFieldDescriptor *last_field = desc->fields + 0;
ScannedMember first_member_slab[1UL <<
FIRST_SCANNED_MEMBER_SLAB_SIZE_LOG2];
/*
* scanned_member_slabs[i] is an array of arrays of ScannedMember.
* The first slab (scanned_member_slabs[0] is just a pointer to
* first_member_slab), above. All subsequent slabs will be allocated
* using the allocator.
*/
ScannedMember *scanned_member_slabs[MAX_SCANNED_MEMBER_SLAB + 1];
unsigned which_slab = 0; /* the slab we are currently populating */
unsigned in_slab_index = 0; /* number of members in the slab */
size_t n_unknown = 0;
unsigned f;
unsigned j;
unsigned i_slab;
unsigned last_field_index = 0;
unsigned required_fields_bitmap_len;
unsigned char required_fields_bitmap_stack[16];
unsigned char *required_fields_bitmap = required_fields_bitmap_stack;
protobuf_c_boolean required_fields_bitmap_alloced = FALSE;
ASSERT_IS_MESSAGE_DESCRIPTOR(desc);
if (allocator == NULL)
allocator = &protobuf_c__allocator;
rv = do_alloc(allocator, desc->sizeof_message);
if (!rv)
return (NULL);
scanned_member_slabs[0] = first_member_slab;
required_fields_bitmap_len = (desc->n_fields + 7) / 8;
if (required_fields_bitmap_len > sizeof(required_fields_bitmap_stack)) {
required_fields_bitmap = do_alloc(allocator, required_fields_bitmap_len);
if (!required_fields_bitmap) {
do_free(allocator, rv);
return (NULL);
}
required_fields_bitmap_alloced = TRUE;
}
memset(required_fields_bitmap, 0, required_fields_bitmap_len);
/*
* Generated code always defines "message_init". However, we provide a
* fallback for (1) users of old protobuf-c generated-code that do not
* provide the function, and (2) descriptors constructed from some other
* source (most likely, direct construction from the .proto file).
*/
if (desc->message_init != NULL)
protobuf_c_message_init(desc, rv);
else
message_init_generic(desc, rv);
while (rem > 0) {
uint32_t tag;
ProtobufCWireType wire_type;
size_t used = parse_tag_and_wiretype(rem, at, &tag, &wire_type);
const ProtobufCFieldDescriptor *field;
ScannedMember tmp;
if (used == 0) {
PROTOBUF_C_UNPACK_ERROR("error parsing tag/wiretype at offset %u",
(unsigned) (at - data));
goto error_cleanup_during_scan;
}
/*
* \todo Consider optimizing for field[1].id == tag, if field[1]
* exists!
*/
if (last_field == NULL || last_field->id != tag) {
/* lookup field */
int field_index =
int_range_lookup(desc->n_field_ranges,
desc->field_ranges,
tag);
if (field_index < 0) {
field = NULL;
n_unknown++;
} else {
field = desc->fields + field_index;
last_field = field;
last_field_index = field_index;
}
} else {
field = last_field;
}
if (field != NULL && field->label == PROTOBUF_C_LABEL_REQUIRED)
REQUIRED_FIELD_BITMAP_SET(last_field_index);
at += used;
rem -= used;
tmp.tag = tag;
tmp.wire_type = wire_type;
tmp.field = field;
tmp.data = at;
tmp.length_prefix_len = 0;
switch (wire_type) {
case PROTOBUF_C_WIRE_TYPE_VARINT: {
unsigned max_len = rem < 10 ? rem : 10;
unsigned i;
for (i = 0; i < max_len; i++)
if ((at[i] & 0x80) == 0)
break;
if (i == max_len) {
PROTOBUF_C_UNPACK_ERROR("unterminated varint at offset %u",
(unsigned) (at - data));
goto error_cleanup_during_scan;
}
tmp.len = i + 1;
break;
}
case PROTOBUF_C_WIRE_TYPE_64BIT:
if (rem < 8) {
PROTOBUF_C_UNPACK_ERROR("too short after 64bit wiretype at offset %u",
(unsigned) (at - data));
goto error_cleanup_during_scan;
}
tmp.len = 8;
break;
case PROTOBUF_C_WIRE_TYPE_LENGTH_PREFIXED: {
size_t pref_len;
tmp.len = scan_length_prefixed_data(rem, at, &pref_len);
if (tmp.len == 0) {
/* NOTE: scan_length_prefixed_data calls UNPACK_ERROR */
goto error_cleanup_during_scan;
}
tmp.length_prefix_len = pref_len;
break;
}
case PROTOBUF_C_WIRE_TYPE_32BIT:
if (rem < 4) {
PROTOBUF_C_UNPACK_ERROR("too short after 32bit wiretype at offset %u",
(unsigned) (at - data));
goto error_cleanup_during_scan;
}
tmp.len = 4;
break;
default:
PROTOBUF_C_UNPACK_ERROR("unsupported tag %u at offset %u",
wire_type, (unsigned) (at - data));
goto error_cleanup_during_scan;
}
if (in_slab_index == (1UL <<
(which_slab + FIRST_SCANNED_MEMBER_SLAB_SIZE_LOG2)))
{
size_t size;
in_slab_index = 0;
if (which_slab == MAX_SCANNED_MEMBER_SLAB) {
PROTOBUF_C_UNPACK_ERROR("too many fields");
goto error_cleanup_during_scan;
}
which_slab++;
size = sizeof(ScannedMember)
<< (which_slab + FIRST_SCANNED_MEMBER_SLAB_SIZE_LOG2);
scanned_member_slabs[which_slab] = do_alloc(allocator, size);
if (scanned_member_slabs[which_slab] == NULL)
goto error_cleanup_during_scan;
}
scanned_member_slabs[which_slab][in_slab_index++] = tmp;
if (field != NULL && field->label == PROTOBUF_C_LABEL_REPEATED) {
size_t *n = STRUCT_MEMBER_PTR(size_t, rv,
field->quantifier_offset);
if (wire_type == PROTOBUF_C_WIRE_TYPE_LENGTH_PREFIXED &&
(0 != (field->flags & PROTOBUF_C_FIELD_FLAG_PACKED) ||
is_packable_type(field->type)))
{
size_t count;
if (!count_packed_elements(field->type,
tmp.len -
tmp.length_prefix_len,
tmp.data +
tmp.length_prefix_len,
&count))
{
PROTOBUF_C_UNPACK_ERROR("counting packed elements");
goto error_cleanup_during_scan;
}
*n += count;
} else {
*n += 1;
}
}
at += tmp.len;
rem -= tmp.len;
}
/* allocate space for repeated fields, also check that all required fields have been set */
for (f = 0; f < desc->n_fields; f++) {
const ProtobufCFieldDescriptor *field = desc->fields + f;
if (field->label == PROTOBUF_C_LABEL_REPEATED) {
size_t siz =
sizeof_elt_in_repeated_array(field->type);
size_t *n_ptr =
STRUCT_MEMBER_PTR(size_t, rv,
field->quantifier_offset);
if (*n_ptr != 0) {
unsigned n = *n_ptr;
void *a;
*n_ptr = 0;
assert(rv->descriptor != NULL);
#define CLEAR_REMAINING_N_PTRS() \
for(f++;f < desc->n_fields; f++) \
{ \
field = desc->fields + f; \
if (field->label == PROTOBUF_C_LABEL_REPEATED) \
STRUCT_MEMBER (size_t, rv, field->quantifier_offset) = 0; \
}
a = do_alloc(allocator, siz * n);
if (!a) {
CLEAR_REMAINING_N_PTRS();
goto error_cleanup;
}
STRUCT_MEMBER(void *, rv, field->offset) = a;
}
} else if (field->label == PROTOBUF_C_LABEL_REQUIRED) {
if (field->default_value == NULL &&
!REQUIRED_FIELD_BITMAP_IS_SET(f))
{
CLEAR_REMAINING_N_PTRS();
PROTOBUF_C_UNPACK_ERROR("message '%s': missing required field '%s'",
desc->name, field->name);
goto error_cleanup;
}
}
}
#undef CLEAR_REMAINING_N_PTRS
/* allocate space for unknown fields */
if (n_unknown) {
rv->unknown_fields = do_alloc(allocator,
n_unknown * sizeof(ProtobufCMessageUnknownField));
if (rv->unknown_fields == NULL)
goto error_cleanup;
}
/* do real parsing */
for (i_slab = 0; i_slab <= which_slab; i_slab++) {
unsigned max = (i_slab == which_slab) ?
in_slab_index : (1UL << (i_slab + 4));
ScannedMember *slab = scanned_member_slabs[i_slab];
for (j = 0; j < max; j++) {
if (!parse_member(slab + j, rv, allocator)) {
PROTOBUF_C_UNPACK_ERROR("error parsing member %s of %s",
slab->field ? slab->field->name : "*unknown-field*",
desc->name);
goto error_cleanup;
}
}
}
/* cleanup */
for (j = 1; j <= which_slab; j++)
do_free(allocator, scanned_member_slabs[j]);
if (required_fields_bitmap_alloced)
do_free(allocator, required_fields_bitmap);
return rv;
error_cleanup:
protobuf_c_message_free_unpacked(rv, allocator);
for (j = 1; j <= which_slab; j++)
do_free(allocator, scanned_member_slabs[j]);
if (required_fields_bitmap_alloced)
do_free(allocator, required_fields_bitmap);
return NULL;
error_cleanup_during_scan:
do_free(allocator, rv);
for (j = 1; j <= which_slab; j++)
do_free(allocator, scanned_member_slabs[j]);
if (required_fields_bitmap_alloced)
do_free(allocator, required_fields_bitmap);
return NULL;
}
void
protobuf_c_message_free_unpacked(ProtobufCMessage *message,
ProtobufCAllocator *allocator)
{
const ProtobufCMessageDescriptor *desc;
unsigned f;
if (message == NULL)
return;
desc = message->descriptor;
ASSERT_IS_MESSAGE(message);
if (allocator == NULL)
allocator = &protobuf_c__allocator;
message->descriptor = NULL;
for (f = 0; f < desc->n_fields; f++) {
if (0 != (desc->fields[f].flags & PROTOBUF_C_FIELD_FLAG_ONEOF) &&
desc->fields[f].id !=
STRUCT_MEMBER(uint32_t, message, desc->fields[f].quantifier_offset))
{
/* This is not the selected oneof, skip it */
continue;
}
if (desc->fields[f].label == PROTOBUF_C_LABEL_REPEATED) {
size_t n = STRUCT_MEMBER(size_t,
message,
desc->fields[f].quantifier_offset);
void *arr = STRUCT_MEMBER(void *,
message,
desc->fields[f].offset);
if (arr != NULL) {
if (desc->fields[f].type == PROTOBUF_C_TYPE_STRING) {
unsigned i;
for (i = 0; i < n; i++)
do_free(allocator, ((char **) arr)[i]);
} else if (desc->fields[f].type == PROTOBUF_C_TYPE_BYTES) {
unsigned i;
for (i = 0; i < n; i++)
do_free(allocator, ((ProtobufCBinaryData *) arr)[i].data);
} else if (desc->fields[f].type == PROTOBUF_C_TYPE_MESSAGE) {
unsigned i;
for (i = 0; i < n; i++)
protobuf_c_message_free_unpacked(
((ProtobufCMessage **) arr)[i],
allocator
);
}
do_free(allocator, arr);
}
} else if (desc->fields[f].type == PROTOBUF_C_TYPE_STRING) {
char *str = STRUCT_MEMBER(char *, message,
desc->fields[f].offset);
if (str && str != desc->fields[f].default_value)
do_free(allocator, str);
} else if (desc->fields[f].type == PROTOBUF_C_TYPE_BYTES) {
void *data = STRUCT_MEMBER(ProtobufCBinaryData, message,
desc->fields[f].offset).data;
const ProtobufCBinaryData *default_bd;
default_bd = desc->fields[f].default_value;
if (data != NULL &&
(default_bd == NULL ||
default_bd->data != data))
{
do_free(allocator, data);
}
} else if (desc->fields[f].type == PROTOBUF_C_TYPE_MESSAGE) {
ProtobufCMessage *sm;
sm = STRUCT_MEMBER(ProtobufCMessage *, message,
desc->fields[f].offset);
if (sm && sm != desc->fields[f].default_value)
protobuf_c_message_free_unpacked(sm, allocator);
}
}
for (f = 0; f < message->n_unknown_fields; f++)
do_free(allocator, message->unknown_fields[f].data);
if (message->unknown_fields != NULL)
do_free(allocator, message->unknown_fields);
do_free(allocator, message);
}
void
protobuf_c_message_init(const ProtobufCMessageDescriptor * descriptor,
void *message)
{
descriptor->message_init((ProtobufCMessage *) (message));
}
protobuf_c_boolean
protobuf_c_message_check(const ProtobufCMessage *message)
{
unsigned i;
if (!message ||
!message->descriptor ||
message->descriptor->magic != PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC)
{
return FALSE;
}
for (i = 0; i < message->descriptor->n_fields; i++) {
const ProtobufCFieldDescriptor *f = message->descriptor->fields + i;
ProtobufCType type = f->type;
ProtobufCLabel label = f->label;
void *field = STRUCT_MEMBER_P (message, f->offset);
if (label == PROTOBUF_C_LABEL_REPEATED) {
size_t *quantity = STRUCT_MEMBER_P (message, f->quantifier_offset);
if (*quantity > 0 && *(void **) field == NULL) {
return FALSE;
}
if (type == PROTOBUF_C_TYPE_MESSAGE) {
ProtobufCMessage **submessage = *(ProtobufCMessage ***) field;
unsigned j;
for (j = 0; j < *quantity; j++) {
if (!protobuf_c_message_check(submessage[j]))
return FALSE;
}
} else if (type == PROTOBUF_C_TYPE_STRING) {
char **string = *(char ***) field;
unsigned j;
for (j = 0; j < *quantity; j++) {
if (!string[j])
return FALSE;
}
} else if (type == PROTOBUF_C_TYPE_BYTES) {
ProtobufCBinaryData *bd = *(ProtobufCBinaryData **) field;
unsigned j;
for (j = 0; j < *quantity; j++) {
if (bd[j].len > 0 && bd[j].data == NULL)
return FALSE;
}
}
} else { /* PROTOBUF_C_LABEL_REQUIRED or PROTOBUF_C_LABEL_OPTIONAL */
if (type == PROTOBUF_C_TYPE_MESSAGE) {
ProtobufCMessage *submessage = *(ProtobufCMessage **) field;
if (label == PROTOBUF_C_LABEL_REQUIRED || submessage != NULL) {
if (!protobuf_c_message_check(submessage))
return FALSE;
}
} else if (type == PROTOBUF_C_TYPE_STRING) {
char *string = *(char **) field;
if (label == PROTOBUF_C_LABEL_REQUIRED && string == NULL)
return FALSE;
} else if (type == PROTOBUF_C_TYPE_BYTES) {
protobuf_c_boolean *has = STRUCT_MEMBER_P (message, f->quantifier_offset);
ProtobufCBinaryData *bd = field;
if (label == PROTOBUF_C_LABEL_REQUIRED || *has == TRUE) {
if (bd->len > 0 && bd->data == NULL)
return FALSE;
}
}
}
}
return TRUE;
}
/* === services === */
typedef void (*GenericHandler) (void *service,
const ProtobufCMessage *input,
ProtobufCClosure closure,
void *closure_data);
void
protobuf_c_service_invoke_internal(ProtobufCService *service,
unsigned method_index,
const ProtobufCMessage *input,
ProtobufCClosure closure,
void *closure_data)
{
GenericHandler *handlers;
GenericHandler handler;
/*
* Verify that method_index is within range. If this fails, you are
* likely invoking a newly added method on an old service. (Although
* other memory corruption bugs can cause this assertion too.)
*/
assert(method_index < service->descriptor->n_methods);
/*
* Get the array of virtual methods (which are enumerated by the
* generated code).
*/
handlers = (GenericHandler *) (service + 1);
/*
* Get our method and invoke it.
* \todo Seems like handler == NULL is a situation that needs handling.
*/
handler = handlers[method_index];
(*handler)(service, input, closure, closure_data);
}
void
protobuf_c_service_generated_init(ProtobufCService *service,
const ProtobufCServiceDescriptor *descriptor,
ProtobufCServiceDestroy destroy)
{
ASSERT_IS_SERVICE_DESCRIPTOR(descriptor);
service->descriptor = descriptor;
service->destroy = destroy;
service->invoke = protobuf_c_service_invoke_internal;
memset(service + 1, 0, descriptor->n_methods * sizeof(GenericHandler));
}
void protobuf_c_service_destroy(ProtobufCService *service)
{
service->destroy(service);
}
/* --- querying the descriptors --- */
const ProtobufCEnumValue *
protobuf_c_enum_descriptor_get_value_by_name(const ProtobufCEnumDescriptor *desc,
const char *name)
{
unsigned start = 0;
unsigned count;
if (desc == NULL || desc->values_by_name == NULL)
return NULL;
count = desc->n_value_names;
while (count > 1) {
unsigned mid = start + count / 2;
int rv = strcmp(desc->values_by_name[mid].name, name);
if (rv == 0)
return desc->values + desc->values_by_name[mid].index;
else if (rv < 0) {
count = start + count - (mid + 1);
start = mid + 1;
} else
count = mid - start;
}
if (count == 0)
return NULL;
if (strcmp(desc->values_by_name[start].name, name) == 0)
return desc->values + desc->values_by_name[start].index;
return NULL;
}
const ProtobufCEnumValue *
protobuf_c_enum_descriptor_get_value(const ProtobufCEnumDescriptor *desc,
int value)
{
int rv = int_range_lookup(desc->n_value_ranges, desc->value_ranges, value);
if (rv < 0)
return NULL;
return desc->values + rv;
}
const ProtobufCFieldDescriptor *
protobuf_c_message_descriptor_get_field_by_name(const ProtobufCMessageDescriptor *desc,
const char *name)
{
unsigned start = 0;
unsigned count;
const ProtobufCFieldDescriptor *field;
if (desc == NULL || desc->fields_sorted_by_name == NULL)
return NULL;
count = desc->n_fields;
while (count > 1) {
unsigned mid = start + count / 2;
int rv;
field = desc->fields + desc->fields_sorted_by_name[mid];
rv = strcmp(field->name, name);
if (rv == 0)
return field;
else if (rv < 0) {
count = start + count - (mid + 1);
start = mid + 1;
} else
count = mid - start;
}
if (count == 0)
return NULL;
field = desc->fields + desc->fields_sorted_by_name[start];
if (strcmp(field->name, name) == 0)
return field;
return NULL;
}
const ProtobufCFieldDescriptor *
protobuf_c_message_descriptor_get_field(const ProtobufCMessageDescriptor *desc,
unsigned value)
{
int rv = int_range_lookup(desc->n_field_ranges,desc->field_ranges, value);
if (rv < 0)
return NULL;
return desc->fields + rv;
}
const ProtobufCMethodDescriptor *
protobuf_c_service_descriptor_get_method_by_name(const ProtobufCServiceDescriptor *desc,
const char *name)
{
unsigned start = 0;
unsigned count;
if (desc == NULL || desc->method_indices_by_name == NULL)
return NULL;
count = desc->n_methods;
while (count > 1) {
unsigned mid = start + count / 2;
unsigned mid_index = desc->method_indices_by_name[mid];
const char *mid_name = desc->methods[mid_index].name;
int rv = strcmp(mid_name, name);
if (rv == 0)
return desc->methods + desc->method_indices_by_name[mid];
if (rv < 0) {
count = start + count - (mid + 1);
start = mid + 1;
} else {
count = mid - start;
}
}
if (count == 0)
return NULL;
if (strcmp(desc->methods[desc->method_indices_by_name[start]].name, name) == 0)
return desc->methods + desc->method_indices_by_name[start];
return NULL;
}
/*
* Copyright (c) 2008-2017, Dave Benson and the protobuf-c authors.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following disclaimer
* in the documentation and/or other materials provided with the
* distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/*! \file
* \mainpage Introduction
*
* This is [protobuf-c], a C implementation of [Protocol Buffers].
*
* This file defines the public API for the `libprotobuf-c` support library.
* This API includes interfaces that can be used directly by client code as well
* as the interfaces used by the code generated by the `protoc-c` compiler.
*
* The `libprotobuf-c` support library performs the actual serialization and
* deserialization of Protocol Buffers messages. It interacts with structures,
* definitions, and metadata generated by the `protoc-c` compiler from .proto
* files.
*
* \authors Dave Benson and the `protobuf-c` authors.
*
* \copyright 2008-2014. Licensed under the terms of the [BSD-2-Clause] license.
*
* [protobuf-c]: https://github.com/protobuf-c/protobuf-c
* [Protocol Buffers]: https://developers.google.com/protocol-buffers/
* [BSD-2-Clause]: http://opensource.org/licenses/BSD-2-Clause
*
* \page gencode Generated Code
*
* For each enum, we generate a C enum. For each message, we generate a C
* structure which can be cast to a `ProtobufCMessage`.
*
* For each enum and message, we generate a descriptor object that allows us to
* implement a kind of reflection on the structures.
*
* First, some naming conventions:
*
* - The name of the type for enums and messages and services is camel case
* (meaning WordsAreCrammedTogether) except that double underscores are used
* to delimit scopes. For example, the following `.proto` file:
*
~~~{.proto}
package foo.bar;
message BazBah {
optional int32 val = 1;
}
~~~
*
* would generate a C type `Foo__Bar__BazBah`.
*
* - Identifiers for functions and globals are all lowercase, with camel case
* words separated by single underscores. For example, one of the function
* prototypes generated by `protoc-c` for the above example:
*
~~~{.c}
Foo__Bar__BazBah *
foo__bar__baz_bah__unpack
(ProtobufCAllocator *allocator,
size_t len,
const uint8_t *data);
~~~
*
* - Identifiers for enum values contain an uppercase prefix which embeds the
* package name and the enum type name.
*
* - A double underscore is used to separate further components of identifier
* names.
*
* For example, in the name of the unpack function above, the package name
* `foo.bar` has become `foo__bar`, the message name BazBah has become
* `baz_bah`, and the method name is `unpack`. These are all joined with double
* underscores to form the C identifier `foo__bar__baz_bah__unpack`.
*
* We also generate descriptor objects for messages and enums. These are
* declared in the `.pb-c.h` files:
*
~~~{.c}
extern const ProtobufCMessageDescriptor foo__bar__baz_bah__descriptor;
~~~
*
* The message structures all begin with `ProtobufCMessageDescriptor *` which is
* sufficient to allow them to be cast to `ProtobufCMessage`.
*
* For each message defined in a `.proto` file, we generate a number of
* functions and macros. Each function name contains a prefix based on the
* package name and message name in order to make it a unique C identifier.
*
* - `INIT`. Statically initializes a message object, initializing its
* descriptor and setting its fields to default values. Uninitialized
* messages cannot be processed by the protobuf-c library.
*
~~~{.c}
#define FOO__BAR__BAZ_BAH__INIT \
{ PROTOBUF_C_MESSAGE_INIT (&foo__bar__baz_bah__descriptor), 0 }
~~~
* - `init()`. Initializes a message object, initializing its descriptor and
* setting its fields to default values. Uninitialized messages cannot be
* processed by the protobuf-c library.
*
~~~{.c}
void foo__bar__baz_bah__init
(Foo__Bar__BazBah *message);
~~~
* - `unpack()`. Unpacks data for a particular message format. Note that the
* `allocator` parameter is usually `NULL` to indicate that the system's
* `malloc()` and `free()` functions should be used for dynamically allocating
* memory.
*
~~~{.c}
Foo__Bar__BazBah *
foo__bar__baz_bah__unpack
(ProtobufCAllocator *allocator,
size_t len,
const uint8_t *data);
~~~
*
* - `free_unpacked()`. Frees a message object obtained with the `unpack()`
* method. Freeing `NULL` is allowed (the same as with `free()`).
*
~~~{.c}
void foo__bar__baz_bah__free_unpacked
(Foo__Bar__BazBah *message,
ProtobufCAllocator *allocator);
~~~
*
* - `get_packed_size()`. Calculates the length in bytes of the serialized
* representation of the message object.
*
~~~{.c}
size_t foo__bar__baz_bah__get_packed_size
(const Foo__Bar__BazBah *message);
~~~
*
* - `pack()`. Pack a message object into a preallocated buffer. Assumes that
* the buffer is large enough. (Use `get_packed_size()` first.)
*
~~~{.c}
size_t foo__bar__baz_bah__pack
(const Foo__Bar__BazBah *message,
uint8_t *out);
~~~
*
* - `pack_to_buffer()`. Packs a message into a "virtual buffer". This is an
* object which defines an "append bytes" callback to consume data as it is
* serialized.
*
~~~{.c}
size_t foo__bar__baz_bah__pack_to_buffer
(const Foo__Bar__BazBah *message,
ProtobufCBuffer *buffer);
~~~
*
* \page pack Packing and unpacking messages
*
* To pack a message, first compute the packed size of the message with
* protobuf_c_message_get_packed_size(), then allocate a buffer of at least
* that size, then call protobuf_c_message_pack().
*
* Alternatively, a message can be serialized without calculating the final size
* first. Use the protobuf_c_message_pack_to_buffer() function and provide a
* ProtobufCBuffer object which implements an "append" method that consumes
* data.
*
* To unpack a message, call the protobuf_c_message_unpack() function. The
* result can be cast to an object of the type that matches the descriptor for
* the message.
*
* The result of unpacking a message should be freed with
* protobuf_c_message_free_unpacked().
*/
#ifndef PROTOBUF_C_H
#define PROTOBUF_C_H
#include <assert.h>
#include <limits.h>
#include <stddef.h>
#include <stdint.h>
#ifdef __cplusplus
# define PROTOBUF_C__BEGIN_DECLS extern "C" {
# define PROTOBUF_C__END_DECLS }
#else
# define PROTOBUF_C__BEGIN_DECLS
# define PROTOBUF_C__END_DECLS
#endif
PROTOBUF_C__BEGIN_DECLS
#if defined(_WIN32) && defined(PROTOBUF_C_USE_SHARED_LIB)
# ifdef PROTOBUF_C_EXPORT
# define PROTOBUF_C__API __declspec(dllexport)
# else
# define PROTOBUF_C__API __declspec(dllimport)
# endif
#else
# define PROTOBUF_C__API
#endif
#if !defined(PROTOBUF_C__NO_DEPRECATED) && \
((__GNUC__ > 3) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 1))
# define PROTOBUF_C__DEPRECATED __attribute__((__deprecated__))
#else
# define PROTOBUF_C__DEPRECATED
#endif
#ifndef PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE
#define PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(enum_name) \
, _##enum_name##_IS_INT_SIZE = INT_MAX
#endif
#define PROTOBUF_C__SERVICE_DESCRIPTOR_MAGIC 0x14159bc3
#define PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC 0x28aaeef9
#define PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC 0x114315af
/* Empty string used for initializers */
extern const char protobuf_c_empty_string[];
/**
* \defgroup api Public API
*
* This is the public API for `libprotobuf-c`. These interfaces are stable and
* subject to Semantic Versioning guarantees.
*
* @{
*/
/**
* Values for the `flags` word in `ProtobufCFieldDescriptor`.
*/
typedef enum {
/** Set if the field is repeated and marked with the `packed` option. */
PROTOBUF_C_FIELD_FLAG_PACKED = (1 << 0),
/** Set if the field is marked with the `deprecated` option. */
PROTOBUF_C_FIELD_FLAG_DEPRECATED = (1 << 1),
/** Set if the field is a member of a oneof (union). */
PROTOBUF_C_FIELD_FLAG_ONEOF = (1 << 2),
} ProtobufCFieldFlag;
/**
* Message field rules.
*
* \see [Defining A Message Type] in the Protocol Buffers documentation.
*
* [Defining A Message Type]:
* https://developers.google.com/protocol-buffers/docs/proto#simple
*/
typedef enum {
/** A well-formed message must have exactly one of this field. */
PROTOBUF_C_LABEL_REQUIRED,
/**
* A well-formed message can have zero or one of this field (but not
* more than one).
*/
PROTOBUF_C_LABEL_OPTIONAL,
/**
* This field can be repeated any number of times (including zero) in a
* well-formed message. The order of the repeated values will be
* preserved.
*/
PROTOBUF_C_LABEL_REPEATED,
/**
* This field has no label. This is valid only in proto3 and is
* equivalent to OPTIONAL but no "has" quantifier will be consulted.
*/
PROTOBUF_C_LABEL_NONE,
} ProtobufCLabel;
/**
* Field value types.
*
* \see [Scalar Value Types] in the Protocol Buffers documentation.
*
* [Scalar Value Types]:
* https://developers.google.com/protocol-buffers/docs/proto#scalar
*/
typedef enum {
PROTOBUF_C_TYPE_INT32, /**< int32 */
PROTOBUF_C_TYPE_SINT32, /**< signed int32 */
PROTOBUF_C_TYPE_SFIXED32, /**< signed int32 (4 bytes) */
PROTOBUF_C_TYPE_INT64, /**< int64 */
PROTOBUF_C_TYPE_SINT64, /**< signed int64 */
PROTOBUF_C_TYPE_SFIXED64, /**< signed int64 (8 bytes) */
PROTOBUF_C_TYPE_UINT32, /**< unsigned int32 */
PROTOBUF_C_TYPE_FIXED32, /**< unsigned int32 (4 bytes) */
PROTOBUF_C_TYPE_UINT64, /**< unsigned int64 */
PROTOBUF_C_TYPE_FIXED64, /**< unsigned int64 (8 bytes) */
PROTOBUF_C_TYPE_FLOAT, /**< float */
PROTOBUF_C_TYPE_DOUBLE, /**< double */
PROTOBUF_C_TYPE_BOOL, /**< boolean */
PROTOBUF_C_TYPE_ENUM, /**< enumerated type */
PROTOBUF_C_TYPE_STRING, /**< UTF-8 or ASCII string */
PROTOBUF_C_TYPE_BYTES, /**< arbitrary byte sequence */
PROTOBUF_C_TYPE_MESSAGE, /**< nested message */
} ProtobufCType;
/**
* Field wire types.
*
* \see [Message Structure] in the Protocol Buffers documentation.
*
* [Message Structure]:
* https://developers.google.com/protocol-buffers/docs/encoding#structure
*/
typedef enum {
PROTOBUF_C_WIRE_TYPE_VARINT = 0,
PROTOBUF_C_WIRE_TYPE_64BIT = 1,
PROTOBUF_C_WIRE_TYPE_LENGTH_PREFIXED = 2,
/* "Start group" and "end group" wire types are unsupported. */
PROTOBUF_C_WIRE_TYPE_32BIT = 5,
} ProtobufCWireType;
struct ProtobufCAllocator;
struct ProtobufCBinaryData;
struct ProtobufCBuffer;
struct ProtobufCBufferSimple;
struct ProtobufCEnumDescriptor;
struct ProtobufCEnumValue;
struct ProtobufCEnumValueIndex;
struct ProtobufCFieldDescriptor;
struct ProtobufCIntRange;
struct ProtobufCMessage;
struct ProtobufCMessageDescriptor;
struct ProtobufCMessageUnknownField;
struct ProtobufCMethodDescriptor;
struct ProtobufCService;
struct ProtobufCServiceDescriptor;
typedef struct ProtobufCAllocator ProtobufCAllocator;
typedef struct ProtobufCBinaryData ProtobufCBinaryData;
typedef struct ProtobufCBuffer ProtobufCBuffer;
typedef struct ProtobufCBufferSimple ProtobufCBufferSimple;
typedef struct ProtobufCEnumDescriptor ProtobufCEnumDescriptor;
typedef struct ProtobufCEnumValue ProtobufCEnumValue;
typedef struct ProtobufCEnumValueIndex ProtobufCEnumValueIndex;
typedef struct ProtobufCFieldDescriptor ProtobufCFieldDescriptor;
typedef struct ProtobufCIntRange ProtobufCIntRange;
typedef struct ProtobufCMessage ProtobufCMessage;
typedef struct ProtobufCMessageDescriptor ProtobufCMessageDescriptor;
typedef struct ProtobufCMessageUnknownField ProtobufCMessageUnknownField;
typedef struct ProtobufCMethodDescriptor ProtobufCMethodDescriptor;
typedef struct ProtobufCService ProtobufCService;
typedef struct ProtobufCServiceDescriptor ProtobufCServiceDescriptor;
/** Boolean type. */
typedef int protobuf_c_boolean;
typedef void (*ProtobufCClosure)(const ProtobufCMessage *, void *closure_data);
typedef void (*ProtobufCMessageInit)(ProtobufCMessage *);
typedef void (*ProtobufCServiceDestroy)(ProtobufCService *);
/**
* Structure for defining a custom memory allocator.
*/
struct ProtobufCAllocator {
/** Function to allocate memory. */
void *(*alloc)(void *allocator_data, size_t size);
/** Function to free memory. */
void (*free)(void *allocator_data, void *pointer);
/** Opaque pointer passed to `alloc` and `free` functions. */
void *allocator_data;
};
/**
* Structure for the protobuf `bytes` scalar type.
*
* The data contained in a `ProtobufCBinaryData` is an arbitrary sequence of
* bytes. It may contain embedded `NUL` characters and is not required to be
* `NUL`-terminated.
*/
struct ProtobufCBinaryData {
size_t len; /**< Number of bytes in the `data` field. */
uint8_t *data; /**< Data bytes. */
};
/**
* Structure for defining a virtual append-only buffer. Used by
* protobuf_c_message_pack_to_buffer() to abstract the consumption of serialized
* bytes.
*
* `ProtobufCBuffer` "subclasses" may be defined on the stack. For example, to
* write to a `FILE` object:
*
~~~{.c}
typedef struct {
ProtobufCBuffer base;
FILE *fp;
} BufferAppendToFile;
static void
my_buffer_file_append(ProtobufCBuffer *buffer,
size_t len,
const uint8_t *data)
{
BufferAppendToFile *file_buf = (BufferAppendToFile *) buffer;
fwrite(data, len, 1, file_buf->fp); // XXX: No error handling!
}
~~~
*
* To use this new type of ProtobufCBuffer, it could be called as follows:
*
~~~{.c}
...
BufferAppendToFile tmp = {0};
tmp.base.append = my_buffer_file_append;
tmp.fp = fp;
protobuf_c_message_pack_to_buffer(&message, &tmp);
...
~~~
*/
struct ProtobufCBuffer {
/** Append function. Consumes the `len` bytes stored at `data`. */
void (*append)(ProtobufCBuffer *buffer,
size_t len,
const uint8_t *data);
};
/**
* Simple buffer "subclass" of `ProtobufCBuffer`.
*
* A `ProtobufCBufferSimple` object is declared on the stack and uses a
* scratch buffer provided by the user for the initial allocation. It performs
* exponential resizing, using dynamically allocated memory. A
* `ProtobufCBufferSimple` object can be created and used as follows:
*
~~~{.c}
uint8_t pad[128];
ProtobufCBufferSimple simple = PROTOBUF_C_BUFFER_SIMPLE_INIT(pad);
ProtobufCBuffer *buffer = (ProtobufCBuffer *) &simple;
~~~
*
* `buffer` can now be used with `protobuf_c_message_pack_to_buffer()`. Once a
* message has been serialized to a `ProtobufCBufferSimple` object, the
* serialized data bytes can be accessed from the `.data` field.
*
* To free the memory allocated by a `ProtobufCBufferSimple` object, if any,
* call PROTOBUF_C_BUFFER_SIMPLE_CLEAR() on the object, for example:
*
~~~{.c}
PROTOBUF_C_BUFFER_SIMPLE_CLEAR(&simple);
~~~
*
* \see PROTOBUF_C_BUFFER_SIMPLE_INIT
* \see PROTOBUF_C_BUFFER_SIMPLE_CLEAR
*/
struct ProtobufCBufferSimple {
/** "Base class". */
ProtobufCBuffer base;
/** Number of bytes allocated in `data`. */
size_t alloced;
/** Number of bytes currently stored in `data`. */
size_t len;
/** Data bytes. */
uint8_t *data;
/** Whether `data` must be freed. */
protobuf_c_boolean must_free_data;
/** Allocator to use. May be NULL to indicate the system allocator. */
ProtobufCAllocator *allocator;
};
/**
* Describes an enumeration as a whole, with all of its values.
*/
struct ProtobufCEnumDescriptor {
/** Magic value checked to ensure that the API is used correctly. */
uint32_t magic;
/** The qualified name (e.g., "namespace.Type"). */
const char *name;
/** The unqualified name as given in the .proto file (e.g., "Type"). */
const char *short_name;
/** Identifier used in generated C code. */
const char *c_name;
/** The dot-separated namespace. */
const char *package_name;
/** Number elements in `values`. */
unsigned n_values;
/** Array of distinct values, sorted by numeric value. */
const ProtobufCEnumValue *values;
/** Number of elements in `values_by_name`. */
unsigned n_value_names;
/** Array of named values, including aliases, sorted by name. */
const ProtobufCEnumValueIndex *values_by_name;
/** Number of elements in `value_ranges`. */
unsigned n_value_ranges;
/** Value ranges, for faster lookups by numeric value. */
const ProtobufCIntRange *value_ranges;
/** Reserved for future use. */
void *reserved1;
/** Reserved for future use. */
void *reserved2;
/** Reserved for future use. */
void *reserved3;
/** Reserved for future use. */
void *reserved4;
};
/**
* Represents a single value of an enumeration.
*/
struct ProtobufCEnumValue {
/** The string identifying this value in the .proto file. */
const char *name;
/** The string identifying this value in generated C code. */
const char *c_name;
/** The numeric value assigned in the .proto file. */
int value;
};
/**
* Used by `ProtobufCEnumDescriptor` to look up enum values.
*/
struct ProtobufCEnumValueIndex {
/** Name of the enum value. */
const char *name;
/** Index into values[] array. */
unsigned index;
};
/**
* Describes a single field in a message.
*/
struct ProtobufCFieldDescriptor {
/** Name of the field as given in the .proto file. */
const char *name;
/** Tag value of the field as given in the .proto file. */
uint32_t id;
/** Whether the field is `REQUIRED`, `OPTIONAL`, or `REPEATED`. */
ProtobufCLabel label;
/** The type of the field. */
ProtobufCType type;
/**
* The offset in bytes of the message's C structure's quantifier field
* (the `has_MEMBER` field for optional members or the `n_MEMBER` field
* for repeated members or the case enum for oneofs).
*/
unsigned quantifier_offset;
/**
* The offset in bytes into the message's C structure for the member
* itself.
*/
unsigned offset;
/**
* A type-specific descriptor.
*
* If `type` is `PROTOBUF_C_TYPE_ENUM`, then `descriptor` points to the
* corresponding `ProtobufCEnumDescriptor`.
*
* If `type` is `PROTOBUF_C_TYPE_MESSAGE`, then `descriptor` points to
* the corresponding `ProtobufCMessageDescriptor`.
*
* Otherwise this field is NULL.
*/
const void *descriptor; /* for MESSAGE and ENUM types */
/** The default value for this field, if defined. May be NULL. */
const void *default_value;
/**
* A flag word. Zero or more of the bits defined in the
* `ProtobufCFieldFlag` enum may be set.
*/
uint32_t flags;
/** Reserved for future use. */
unsigned reserved_flags;
/** Reserved for future use. */
void *reserved2;
/** Reserved for future use. */
void *reserved3;
};
/**
* Helper structure for optimizing int => index lookups in the case
* where the keys are mostly consecutive values, as they presumably are for
* enums and fields.
*
* The data structures requires that the values in the original array are
* sorted.
*/
struct ProtobufCIntRange {
int start_value;
unsigned orig_index;
/*
* NOTE: the number of values in the range can be inferred by looking
* at the next element's orig_index. A dummy element is added to make
* this simple.
*/
};
/**
* An instance of a message.
*
* `ProtobufCMessage` is a light-weight "base class" for all messages.
*
* In particular, `ProtobufCMessage` doesn't have any allocation policy
* associated with it. That's because it's common to create `ProtobufCMessage`
* objects on the stack. In fact, that's what we recommend for sending messages.
* If the object is allocated from the stack, you can't really have a memory
* leak.
*
* This means that calls to functions like protobuf_c_message_unpack() which
* return a `ProtobufCMessage` must be paired with a call to a free function,
* like protobuf_c_message_free_unpacked().
*/
struct ProtobufCMessage {
/** The descriptor for this message type. */
const ProtobufCMessageDescriptor *descriptor;
/** The number of elements in `unknown_fields`. */
unsigned n_unknown_fields;
/** The fields that weren't recognized by the parser. */
ProtobufCMessageUnknownField *unknown_fields;
};
/**
* Describes a message.
*/
struct ProtobufCMessageDescriptor {
/** Magic value checked to ensure that the API is used correctly. */
uint32_t magic;
/** The qualified name (e.g., "namespace.Type"). */
const char *name;
/** The unqualified name as given in the .proto file (e.g., "Type"). */
const char *short_name;
/** Identifier used in generated C code. */
const char *c_name;
/** The dot-separated namespace. */
const char *package_name;
/**
* Size in bytes of the C structure representing an instance of this
* type of message.
*/
size_t sizeof_message;
/** Number of elements in `fields`. */
unsigned n_fields;
/** Field descriptors, sorted by tag number. */
const ProtobufCFieldDescriptor *fields;
/** Used for looking up fields by name. */
const unsigned *fields_sorted_by_name;
/** Number of elements in `field_ranges`. */
unsigned n_field_ranges;
/** Used for looking up fields by id. */
const ProtobufCIntRange *field_ranges;
/** Message initialisation function. */
ProtobufCMessageInit message_init;
/** Reserved for future use. */
void *reserved1;
/** Reserved for future use. */
void *reserved2;
/** Reserved for future use. */
void *reserved3;
};
/**
* An unknown message field.
*/
struct ProtobufCMessageUnknownField {
/** The tag number. */
uint32_t tag;
/** The wire type of the field. */
ProtobufCWireType wire_type;
/** Number of bytes in `data`. */
size_t len;
/** Field data. */
uint8_t *data;
};
/**
* Method descriptor.
*/
struct ProtobufCMethodDescriptor {
/** Method name. */
const char *name;
/** Input message descriptor. */
const ProtobufCMessageDescriptor *input;
/** Output message descriptor. */
const ProtobufCMessageDescriptor *output;
};
/**
* Service.
*/
struct ProtobufCService {
/** Service descriptor. */
const ProtobufCServiceDescriptor *descriptor;
/** Function to invoke the service. */
void (*invoke)(ProtobufCService *service,
unsigned method_index,
const ProtobufCMessage *input,
ProtobufCClosure closure,
void *closure_data);
/** Function to destroy the service. */
void (*destroy)(ProtobufCService *service);
};
/**
* Service descriptor.
*/
struct ProtobufCServiceDescriptor {
/** Magic value checked to ensure that the API is used correctly. */
uint32_t magic;
/** Service name. */
const char *name;
/** Short version of service name. */
const char *short_name;
/** C identifier for the service name. */
const char *c_name;
/** Package name. */
const char *package;
/** Number of elements in `methods`. */
unsigned n_methods;
/** Method descriptors, in the order defined in the .proto file. */
const ProtobufCMethodDescriptor *methods;
/** Sort index of methods. */
const unsigned *method_indices_by_name;
};
/**
* Get the version of the protobuf-c library. Note that this is the version of
* the library linked against, not the version of the headers compiled against.
*
* \return A string containing the version number of protobuf-c.
*/
PROTOBUF_C__API
const char *
protobuf_c_version(void);
/**
* Get the version of the protobuf-c library. Note that this is the version of
* the library linked against, not the version of the headers compiled against.
*
* \return A 32 bit unsigned integer containing the version number of
* protobuf-c, represented in base-10 as (MAJOR*1E6) + (MINOR*1E3) + PATCH.
*/
PROTOBUF_C__API
uint32_t
protobuf_c_version_number(void);
/**
* The version of the protobuf-c headers, represented as a string using the same
* format as protobuf_c_version().
*/
#define PROTOBUF_C_VERSION "1.3.0"
/**
* The version of the protobuf-c headers, represented as an integer using the
* same format as protobuf_c_version_number().
*/
#define PROTOBUF_C_VERSION_NUMBER 1003000
/**
* The minimum protoc-c version which works with the current version of the
* protobuf-c headers.
*/
#define PROTOBUF_C_MIN_COMPILER_VERSION 1000000
/**
* Look up a `ProtobufCEnumValue` from a `ProtobufCEnumDescriptor` by name.
*
* \param desc
* The `ProtobufCEnumDescriptor` object.
* \param name
* The `name` field from the corresponding `ProtobufCEnumValue` object to
* match.
* \return
* A `ProtobufCEnumValue` object.
* \retval NULL
* If not found or if the optimize_for = CODE_SIZE option was set.
*/
PROTOBUF_C__API
const ProtobufCEnumValue *
protobuf_c_enum_descriptor_get_value_by_name(
const ProtobufCEnumDescriptor *desc,
const char *name);
/**
* Look up a `ProtobufCEnumValue` from a `ProtobufCEnumDescriptor` by numeric
* value.
*
* \param desc
* The `ProtobufCEnumDescriptor` object.
* \param value
* The `value` field from the corresponding `ProtobufCEnumValue` object to
* match.
*
* \return
* A `ProtobufCEnumValue` object.
* \retval NULL
* If not found.
*/
PROTOBUF_C__API
const ProtobufCEnumValue *
protobuf_c_enum_descriptor_get_value(
const ProtobufCEnumDescriptor *desc,
int value);
/**
* Look up a `ProtobufCFieldDescriptor` from a `ProtobufCMessageDescriptor` by
* the name of the field.
*
* \param desc
* The `ProtobufCMessageDescriptor` object.
* \param name
* The name of the field.
* \return
* A `ProtobufCFieldDescriptor` object.
* \retval NULL
* If not found or if the optimize_for = CODE_SIZE option was set.
*/
PROTOBUF_C__API
const ProtobufCFieldDescriptor *
protobuf_c_message_descriptor_get_field_by_name(
const ProtobufCMessageDescriptor *desc,
const char *name);
/**
* Look up a `ProtobufCFieldDescriptor` from a `ProtobufCMessageDescriptor` by
* the tag value of the field.
*
* \param desc
* The `ProtobufCMessageDescriptor` object.
* \param value
* The tag value of the field.
* \return
* A `ProtobufCFieldDescriptor` object.
* \retval NULL
* If not found.
*/
PROTOBUF_C__API
const ProtobufCFieldDescriptor *
protobuf_c_message_descriptor_get_field(
const ProtobufCMessageDescriptor *desc,
unsigned value);
/**
* Determine the number of bytes required to store the serialised message.
*
* \param message
* The message object to serialise.
* \return
* Number of bytes.
*/
PROTOBUF_C__API
size_t
protobuf_c_message_get_packed_size(const ProtobufCMessage *message);
/**
* Unpack a serialised message into an in-memory representation.
*
* \param descriptor
* The message descriptor.
* \param allocator
* `ProtobufCAllocator` to use for memory allocation. May be NULL to
* specify the default allocator.
* \param len
* Length in bytes of the serialised message.
* \param data
* Pointer to the serialised message.
* \return
* An unpacked message object.
* \retval NULL
* If an error occurred during unpacking.
*/
PROTOBUF_C__API
ProtobufCMessage *
protobuf_c_message_unpack(
const ProtobufCMessageDescriptor *descriptor,
ProtobufCAllocator *allocator,
size_t len,
const uint8_t *data);
/**
* Free an unpacked message object.
*
* This function should be used to deallocate the memory used by a call to
* protobuf_c_message_unpack().
*
* \param message
* The message object to free. May be NULL.
* \param allocator
* `ProtobufCAllocator` to use for memory deallocation. May be NULL to
* specify the default allocator.
*/
PROTOBUF_C__API
void
protobuf_c_message_free_unpacked(
ProtobufCMessage *message,
ProtobufCAllocator *allocator);
/**
* Check the validity of a message object.
*
* Makes sure all required fields (`PROTOBUF_C_LABEL_REQUIRED`) are present.
* Recursively checks nested messages.
*
* \retval TRUE
* Message is valid.
* \retval FALSE
* Message is invalid.
*/
PROTOBUF_C__API
protobuf_c_boolean
protobuf_c_message_check(const ProtobufCMessage *);
/** Message initialiser. */
#define PROTOBUF_C_MESSAGE_INIT(descriptor) { descriptor, 0, NULL }
/**
* Initialise a message object from a message descriptor.
*
* \param descriptor
* Message descriptor.
* \param message
* Allocated block of memory of size `descriptor->sizeof_message`.
*/
PROTOBUF_C__API
void
protobuf_c_message_init(
const ProtobufCMessageDescriptor *descriptor,
void *message);
/**
* Free a service.
*
* \param service
* The service object to free.
*/
PROTOBUF_C__API
void
protobuf_c_service_destroy(ProtobufCService *service);
/**
* Look up a `ProtobufCMethodDescriptor` by name.
*
* \param desc
* Service descriptor.
* \param name
* Name of the method.
*
* \return
* A `ProtobufCMethodDescriptor` object.
* \retval NULL
* If not found or if the optimize_for = CODE_SIZE option was set.
*/
PROTOBUF_C__API
const ProtobufCMethodDescriptor *
protobuf_c_service_descriptor_get_method_by_name(
const ProtobufCServiceDescriptor *desc,
const char *name);
/**
* Initialise a `ProtobufCBufferSimple` object.
*/
#define PROTOBUF_C_BUFFER_SIMPLE_INIT(array_of_bytes) \
{ \
{ protobuf_c_buffer_simple_append }, \
sizeof(array_of_bytes), \
0, \
(array_of_bytes), \
0, \
NULL \
}
/**
* Clear a `ProtobufCBufferSimple` object, freeing any allocated memory.
*/
#define PROTOBUF_C_BUFFER_SIMPLE_CLEAR(simp_buf) \
do { \
if ((simp_buf)->must_free_data) { \
if ((simp_buf)->allocator != NULL) \
(simp_buf)->allocator->free( \
(simp_buf)->allocator, \
(simp_buf)->data); \
else \
free((simp_buf)->data); \
} \
} while (0)
/**
* The `append` method for `ProtobufCBufferSimple`.
*
* \param buffer
* The buffer object to append to. Must actually be a
* `ProtobufCBufferSimple` object.
* \param len
* Number of bytes in `data`.
* \param data
* Data to append.
*/
PROTOBUF_C__API
void
protobuf_c_buffer_simple_append(
ProtobufCBuffer *buffer,
size_t len,
const unsigned char *data);
PROTOBUF_C__API
void
protobuf_c_service_generated_init(
ProtobufCService *service,
const ProtobufCServiceDescriptor *descriptor,
ProtobufCServiceDestroy destroy);
PROTOBUF_C__API
void
protobuf_c_service_invoke_internal(
ProtobufCService *service,
unsigned method_index,
const ProtobufCMessage *input,
ProtobufCClosure closure,
void *closure_data);
/**@}*/
PROTOBUF_C__END_DECLS
#endif /* PROTOBUF_C_H */
...@@ -17,6 +17,7 @@ limitations under the License. */ ...@@ -17,6 +17,7 @@ limitations under the License. */
#include <map> #include <map>
#include <string> #include <string>
#include <vector> #include <vector>
#include <unordered_set>
#include "framework/attribute.h" #include "framework/attribute.h"
#include "framework/scope.h" #include "framework/scope.h"
......
...@@ -14,10 +14,10 @@ limitations under the License. */ ...@@ -14,10 +14,10 @@ limitations under the License. */
#pragma once #pragma once
#include <unordered_map>
#include "common/log.h" #include "common/log.h"
#include "common/enforce.h" #include "common/enforce.h"
#include "common/variant.h" #include "common/variant.h"
#include "framework/framework.pb.h"
#include "framework/framework.pb-c.h" #include "framework/framework.pb-c.h"
namespace paddle_mobile { namespace paddle_mobile {
...@@ -27,69 +27,6 @@ class BlockDesc; ...@@ -27,69 +27,6 @@ class BlockDesc;
class Attribute { class Attribute {
public: public:
static Attribute GetAttrValue(const proto::OpDesc::Attr &attr_desc) {
// std::cout << "begin get attr value" << std::endl;
Attribute attr;
switch (attr_desc.type()) {
case proto::AttrType::BOOLEAN: {
attr.Set<bool>(attr_desc.b());
break;
}
case proto::AttrType::INT: {
attr.Set<int>(attr_desc.i());
break;
}
case proto::AttrType::FLOAT: {
attr.Set<float>(attr_desc.f());
break;
}
case proto::AttrType::STRING: {
attr.Set<std::string>(attr_desc.s());
break;
}
case proto::AttrType::BOOLEANS: {
std::vector<bool> val(attr_desc.bools_size());
for (int i = 0; i < attr_desc.bools_size(); ++i) {
val[i] = attr_desc.bools(i);
}
attr.Set<std::vector<bool>>(val);
break;
}
case proto::AttrType::INTS: {
std::vector<int> val(attr_desc.ints_size());
for (int i = 0; i < attr_desc.ints_size(); ++i) {
val[i] = attr_desc.ints(i);
}
attr.Set<std::vector<int>>(val);
break;
}
case proto::AttrType::FLOATS: {
std::vector<float> val(attr_desc.floats_size());
for (int i = 0; i < attr_desc.floats_size(); ++i) {
val[i] = attr_desc.floats(i);
}
attr.Set<std::vector<float>>(val);
break;
}
case proto::AttrType::STRINGS: {
std::vector<std::string> val(attr_desc.strings_size());
for (int i = 0; i < attr_desc.strings_size(); ++i) {
val[i] = attr_desc.strings(i);
}
attr.Set<std::vector<std::string>>(val);
break;
}
case proto::AttrType::LONG: {
attr.Set<int64_t>(attr_desc.l());
break;
}
default:
// std::cout << " not support " << std::endl;
break;
}
// std::cout << "end get attr value" << std::endl;
return attr;
}
/* /*
* PADDLE_MOBILE__FRAMEWORK__PROTO__ATTR_TYPE__INT = 0, * PADDLE_MOBILE__FRAMEWORK__PROTO__ATTR_TYPE__INT = 0,
......
...@@ -14,8 +14,6 @@ limitations under the License. */ ...@@ -14,8 +14,6 @@ limitations under the License. */
#pragma once #pragma once
#include "framework/framework.pb.h"
namespace paddle_mobile { namespace paddle_mobile {
namespace framework { namespace framework {
......
...@@ -4,7 +4,7 @@ ...@@ -4,7 +4,7 @@
#ifndef PROTOBUF_C_framework_2eproto__INCLUDED #ifndef PROTOBUF_C_framework_2eproto__INCLUDED
#define PROTOBUF_C_framework_2eproto__INCLUDED #define PROTOBUF_C_framework_2eproto__INCLUDED
#include "protobuf-c.h" #include "common/protobuf-c.h"
PROTOBUF_C__BEGIN_DECLS PROTOBUF_C__BEGIN_DECLS
......
因为 它太大了无法显示 source diff 。你可以改为 查看blob
/* Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License. */
// Generated by the protocol buffer compiler. DO NOT EDIT!
// source: framework.proto
#ifndef PROTOBUF_framework_2eproto__INCLUDED
#define PROTOBUF_framework_2eproto__INCLUDED
#include <string>
#include <google/protobuf/stubs/common.h>
#if GOOGLE_PROTOBUF_VERSION < 3004000
#error This file was generated by a newer version of protoc which is
#error incompatible with your Protocol Buffer headers. Please update
#error your headers.
#endif
#if 3004000 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
#error This file was generated by an older version of protoc which is
#error incompatible with your Protocol Buffer headers. Please
#error regenerate this file with a newer version of protoc.
#endif
#include <google/protobuf/arena.h>
#include <google/protobuf/arenastring.h>
#include <google/protobuf/extension_set.h> // IWYU pragma: export
#include <google/protobuf/generated_enum_util.h>
#include <google/protobuf/generated_message_table_driven.h>
#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/message_lite.h>
#include <google/protobuf/metadata_lite.h>
#include <google/protobuf/repeated_field.h> // IWYU pragma: export
// @@protoc_insertion_point(includes)
namespace paddle_mobile {
namespace framework {
namespace proto {
class BlockDesc;
class BlockDescDefaultTypeInternal;
extern BlockDescDefaultTypeInternal _BlockDesc_default_instance_;
class OpDesc;
class OpDescDefaultTypeInternal;
extern OpDescDefaultTypeInternal _OpDesc_default_instance_;
class OpDesc_Attr;
class OpDesc_AttrDefaultTypeInternal;
extern OpDesc_AttrDefaultTypeInternal _OpDesc_Attr_default_instance_;
class OpDesc_Var;
class OpDesc_VarDefaultTypeInternal;
extern OpDesc_VarDefaultTypeInternal _OpDesc_Var_default_instance_;
class OpProto;
class OpProtoDefaultTypeInternal;
extern OpProtoDefaultTypeInternal _OpProto_default_instance_;
class OpProto_Attr;
class OpProto_AttrDefaultTypeInternal;
extern OpProto_AttrDefaultTypeInternal _OpProto_Attr_default_instance_;
class OpProto_Var;
class OpProto_VarDefaultTypeInternal;
extern OpProto_VarDefaultTypeInternal _OpProto_Var_default_instance_;
class ProgramDesc;
class ProgramDescDefaultTypeInternal;
extern ProgramDescDefaultTypeInternal _ProgramDesc_default_instance_;
class VarDesc;
class VarDescDefaultTypeInternal;
extern VarDescDefaultTypeInternal _VarDesc_default_instance_;
class VarType;
class VarTypeDefaultTypeInternal;
extern VarTypeDefaultTypeInternal _VarType_default_instance_;
class VarType_ChannelDesc;
class VarType_ChannelDescDefaultTypeInternal;
extern VarType_ChannelDescDefaultTypeInternal
_VarType_ChannelDesc_default_instance_;
class VarType_LoDTensorArrayDesc;
class VarType_LoDTensorArrayDescDefaultTypeInternal;
extern VarType_LoDTensorArrayDescDefaultTypeInternal
_VarType_LoDTensorArrayDesc_default_instance_;
class VarType_LoDTensorDesc;
class VarType_LoDTensorDescDefaultTypeInternal;
extern VarType_LoDTensorDescDefaultTypeInternal
_VarType_LoDTensorDesc_default_instance_;
class VarType_ReaderDesc;
class VarType_ReaderDescDefaultTypeInternal;
extern VarType_ReaderDescDefaultTypeInternal
_VarType_ReaderDesc_default_instance_;
class VarType_TensorDesc;
class VarType_TensorDescDefaultTypeInternal;
extern VarType_TensorDescDefaultTypeInternal
_VarType_TensorDesc_default_instance_;
class VarType_Tuple;
class VarType_TupleDefaultTypeInternal;
extern VarType_TupleDefaultTypeInternal _VarType_Tuple_default_instance_;
} // namespace proto
} // namespace framework
} // namespace paddle_mobile
namespace paddle_mobile {
namespace framework {
namespace proto {
namespace protobuf_framework_2eproto {
// Internal implementation detail -- do not call these.
struct TableStruct {
static const ::google::protobuf::internal::ParseTableField entries[];
static const ::google::protobuf::internal::AuxillaryParseTableField aux[];
static const ::google::protobuf::internal::ParseTable schema[];
static const ::google::protobuf::uint32 offsets[];
static const ::google::protobuf::internal::FieldMetadata field_metadata[];
static const ::google::protobuf::internal::SerializationTable
serialization_table[];
static void InitDefaultsImpl();
};
void AddDescriptors();
void InitDefaults();
} // namespace protobuf_framework_2eproto
enum VarType_Type {
VarType_Type_BOOL = 0,
VarType_Type_INT16 = 1,
VarType_Type_INT32 = 2,
VarType_Type_INT64 = 3,
VarType_Type_FP16 = 4,
VarType_Type_FP32 = 5,
VarType_Type_FP64 = 6,
VarType_Type_LOD_TENSOR = 7,
VarType_Type_SELECTED_ROWS = 8,
VarType_Type_FEED_MINIBATCH = 9,
VarType_Type_FETCH_LIST = 10,
VarType_Type_STEP_SCOPES = 11,
VarType_Type_LOD_RANK_TABLE = 12,
VarType_Type_LOD_TENSOR_ARRAY = 13,
VarType_Type_PLACE_LIST = 14,
VarType_Type_READER = 15,
VarType_Type_CHANNEL = 16,
VarType_Type_RAW = 17,
VarType_Type_TUPLE = 18
};
bool VarType_Type_IsValid(int value);
const VarType_Type VarType_Type_Type_MIN = VarType_Type_BOOL;
const VarType_Type VarType_Type_Type_MAX = VarType_Type_TUPLE;
const int VarType_Type_Type_ARRAYSIZE = VarType_Type_Type_MAX + 1;
enum AttrType {
INT = 0,
FLOAT = 1,
STRING = 2,
INTS = 3,
FLOATS = 4,
STRINGS = 5,
BOOLEAN = 6,
BOOLEANS = 7,
BLOCK = 8,
LONG = 9
};
bool AttrType_IsValid(int value);
const AttrType AttrType_MIN = INT;
const AttrType AttrType_MAX = LONG;
const int AttrType_ARRAYSIZE = AttrType_MAX + 1;
// ===================================================================
class OpDesc_Attr
: public ::google::protobuf::
MessageLite /* @@protoc_insertion_point(class_definition:paddle_mobile.framework.proto.OpDesc.Attr)
*/
{
public:
OpDesc_Attr();
virtual ~OpDesc_Attr();
OpDesc_Attr(const OpDesc_Attr &from);
inline OpDesc_Attr &operator=(const OpDesc_Attr &from) {
CopyFrom(from);
return *this;
}
#if LANG_CXX11
OpDesc_Attr(OpDesc_Attr &&from) noexcept : OpDesc_Attr() {
*this = ::std::move(from);
}
inline OpDesc_Attr &operator=(OpDesc_Attr &&from) noexcept {
if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
if (this != &from) InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
#endif
inline const ::std::string &unknown_fields() const {
return _internal_metadata_.unknown_fields();
}
inline ::std::string *mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields();
}
static const OpDesc_Attr &default_instance();
static inline const OpDesc_Attr *internal_default_instance() {
return reinterpret_cast<const OpDesc_Attr *>(
&_OpDesc_Attr_default_instance_);
}
static PROTOBUF_CONSTEXPR int const kIndexInFileMessages = 0;
void Swap(OpDesc_Attr *other);
friend void swap(OpDesc_Attr &a, OpDesc_Attr &b) { a.Swap(&b); }
// implements Message
// ----------------------------------------------
inline OpDesc_Attr *New() const PROTOBUF_FINAL { return New(NULL); }
OpDesc_Attr *New(::google::protobuf::Arena *arena) const PROTOBUF_FINAL;
void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite &from)
PROTOBUF_FINAL;
void CopyFrom(const OpDesc_Attr &from);
void MergeFrom(const OpDesc_Attr &from);
void Clear() PROTOBUF_FINAL;
bool IsInitialized() const PROTOBUF_FINAL;
size_t ByteSizeLong() const PROTOBUF_FINAL;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream *input) PROTOBUF_FINAL;
void SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream *output) const PROTOBUF_FINAL;
void DiscardUnknownFields();
int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const;
void InternalSwap(OpDesc_Attr *other);
private:
inline ::google::protobuf::Arena *GetArenaNoVirtual() const { return NULL; }
inline void *MaybeArenaPtr() const { return NULL; }
public:
::std::string GetTypeName() const PROTOBUF_FINAL;
// nested types
// ----------------------------------------------------
// accessors
// -------------------------------------------------------
// repeated int32 ints = 6;
int ints_size() const;
void clear_ints();
static const int kIntsFieldNumber = 6;
::google::protobuf::int32 ints(int index) const;
void set_ints(int index, ::google::protobuf::int32 value);
void add_ints(::google::protobuf::int32 value);
const ::google::protobuf::RepeatedField<::google::protobuf::int32> &ints()
const;
::google::protobuf::RepeatedField<::google::protobuf::int32> *mutable_ints();
// repeated float floats = 7;
int floats_size() const;
void clear_floats();
static const int kFloatsFieldNumber = 7;
float floats(int index) const;
void set_floats(int index, float value);
void add_floats(float value);
const ::google::protobuf::RepeatedField<float> &floats() const;
::google::protobuf::RepeatedField<float> *mutable_floats();
// repeated string strings = 8;
int strings_size() const;
void clear_strings();
static const int kStringsFieldNumber = 8;
const ::std::string &strings(int index) const;
::std::string *mutable_strings(int index);
void set_strings(int index, const ::std::string &value);
#if LANG_CXX11
void set_strings(int index, ::std::string &&value);
#endif
void set_strings(int index, const char *value);
void set_strings(int index, const char *value, size_t size);
::std::string *add_strings();
void add_strings(const ::std::string &value);
#if LANG_CXX11
void add_strings(::std::string &&value);
#endif
void add_strings(const char *value);
void add_strings(const char *value, size_t size);
const ::google::protobuf::RepeatedPtrField<::std::string> &strings() const;
::google::protobuf::RepeatedPtrField<::std::string> *mutable_strings();
// repeated bool bools = 11;
int bools_size() const;
void clear_bools();
static const int kBoolsFieldNumber = 11;
bool bools(int index) const;
void set_bools(int index, bool value);
void add_bools(bool value);
const ::google::protobuf::RepeatedField<bool> &bools() const;
::google::protobuf::RepeatedField<bool> *mutable_bools();
// required string name = 1;
bool has_name() const;
void clear_name();
static const int kNameFieldNumber = 1;
const ::std::string &name() const;
void set_name(const ::std::string &value);
#if LANG_CXX11
void set_name(::std::string &&value);
#endif
void set_name(const char *value);
void set_name(const char *value, size_t size);
::std::string *mutable_name();
::std::string *release_name();
void set_allocated_name(::std::string *name);
// optional string s = 5;
bool has_s() const;
void clear_s();
static const int kSFieldNumber = 5;
const ::std::string &s() const;
void set_s(const ::std::string &value);
#if LANG_CXX11
void set_s(::std::string &&value);
#endif
void set_s(const char *value);
void set_s(const char *value, size_t size);
::std::string *mutable_s();
::std::string *release_s();
void set_allocated_s(::std::string *s);
// required .paddle_mobile.framework.proto.AttrType type = 2;
bool has_type() const;
void clear_type();
static const int kTypeFieldNumber = 2;
::paddle_mobile::framework::proto::AttrType type() const;
void set_type(::paddle_mobile::framework::proto::AttrType value);
// optional int32 i = 3;
bool has_i() const;
void clear_i();
static const int kIFieldNumber = 3;
::google::protobuf::int32 i() const;
void set_i(::google::protobuf::int32 value);
// optional float f = 4;
bool has_f() const;
void clear_f();
static const int kFFieldNumber = 4;
float f() const;
void set_f(float value);
// optional bool b = 10;
bool has_b() const;
void clear_b();
static const int kBFieldNumber = 10;
bool b() const;
void set_b(bool value);
// optional int64 l = 13;
bool has_l() const;
void clear_l();
static const int kLFieldNumber = 13;
::google::protobuf::int64 l() const;
void set_l(::google::protobuf::int64 value);
// optional int32 block_idx = 12;
bool has_block_idx() const;
void clear_block_idx();
static const int kBlockIdxFieldNumber = 12;
::google::protobuf::int32 block_idx() const;
void set_block_idx(::google::protobuf::int32 value);
// @@protoc_insertion_point(class_scope:paddle_mobile.framework.proto.OpDesc.Attr)
private:
void set_has_name();
void clear_has_name();
void set_has_type();
void clear_has_type();
void set_has_i();
void clear_has_i();
void set_has_f();
void clear_has_f();
void set_has_s();
void clear_has_s();
void set_has_b();
void clear_has_b();
void set_has_block_idx();
void clear_has_block_idx();
void set_has_l();
void clear_has_l();
// helper for ByteSizeLong()
size_t RequiredFieldsByteSizeFallback() const;
::google::protobuf::internal::InternalMetadataWithArenaLite
_internal_metadata_;
::google::protobuf::internal::HasBits<1> _has_bits_;
mutable int _cached_size_;
::google::protobuf::RepeatedField<::google::protobuf::int32> ints_;
::google::protobuf::RepeatedField<float> floats_;
::google::protobuf::RepeatedPtrField<::std::string> strings_;
::google::protobuf::RepeatedField<bool> bools_;
::google::protobuf::internal::ArenaStringPtr name_;
::google::protobuf::internal::ArenaStringPtr s_;
int type_;
::google::protobuf::int32 i_;
float f_;
bool b_;
::google::protobuf::int64 l_;
::google::protobuf::int32 block_idx_;
friend struct protobuf_framework_2eproto::TableStruct;
};
// -------------------------------------------------------------------
class OpDesc_Var
: public ::google::protobuf::
MessageLite /* @@protoc_insertion_point(class_definition:paddle_mobile.framework.proto.OpDesc.Var)
*/
{
public:
OpDesc_Var();
virtual ~OpDesc_Var();
OpDesc_Var(const OpDesc_Var &from);
inline OpDesc_Var &operator=(const OpDesc_Var &from) {
CopyFrom(from);
return *this;
}
#if LANG_CXX11
OpDesc_Var(OpDesc_Var &&from) noexcept : OpDesc_Var() {
*this = ::std::move(from);
}
inline OpDesc_Var &operator=(OpDesc_Var &&from) noexcept {
if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
if (this != &from) InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
#endif
inline const ::std::string &unknown_fields() const {
return _internal_metadata_.unknown_fields();
}
inline ::std::string *mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields();
}
static const OpDesc_Var &default_instance();
static inline const OpDesc_Var *internal_default_instance() {
return reinterpret_cast<const OpDesc_Var *>(&_OpDesc_Var_default_instance_);
}
static PROTOBUF_CONSTEXPR int const kIndexInFileMessages = 1;
void Swap(OpDesc_Var *other);
friend void swap(OpDesc_Var &a, OpDesc_Var &b) { a.Swap(&b); }
// implements Message
// ----------------------------------------------
inline OpDesc_Var *New() const PROTOBUF_FINAL { return New(NULL); }
OpDesc_Var *New(::google::protobuf::Arena *arena) const PROTOBUF_FINAL;
void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite &from)
PROTOBUF_FINAL;
void CopyFrom(const OpDesc_Var &from);
void MergeFrom(const OpDesc_Var &from);
void Clear() PROTOBUF_FINAL;
bool IsInitialized() const PROTOBUF_FINAL;
size_t ByteSizeLong() const PROTOBUF_FINAL;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream *input) PROTOBUF_FINAL;
void SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream *output) const PROTOBUF_FINAL;
void DiscardUnknownFields();
int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const;
void InternalSwap(OpDesc_Var *other);
private:
inline ::google::protobuf::Arena *GetArenaNoVirtual() const { return NULL; }
inline void *MaybeArenaPtr() const { return NULL; }
public:
::std::string GetTypeName() const PROTOBUF_FINAL;
// nested types
// ----------------------------------------------------
// accessors
// -------------------------------------------------------
// repeated string arguments = 2;
int arguments_size() const;
void clear_arguments();
static const int kArgumentsFieldNumber = 2;
const ::std::string &arguments(int index) const;
::std::string *mutable_arguments(int index);
void set_arguments(int index, const ::std::string &value);
#if LANG_CXX11
void set_arguments(int index, ::std::string &&value);
#endif
void set_arguments(int index, const char *value);
void set_arguments(int index, const char *value, size_t size);
::std::string *add_arguments();
void add_arguments(const ::std::string &value);
#if LANG_CXX11
void add_arguments(::std::string &&value);
#endif
void add_arguments(const char *value);
void add_arguments(const char *value, size_t size);
const ::google::protobuf::RepeatedPtrField<::std::string> &arguments() const;
::google::protobuf::RepeatedPtrField<::std::string> *mutable_arguments();
// required string parameter = 1;
bool has_parameter() const;
void clear_parameter();
static const int kParameterFieldNumber = 1;
const ::std::string &parameter() const;
void set_parameter(const ::std::string &value);
#if LANG_CXX11
void set_parameter(::std::string &&value);
#endif
void set_parameter(const char *value);
void set_parameter(const char *value, size_t size);
::std::string *mutable_parameter();
::std::string *release_parameter();
void set_allocated_parameter(::std::string *parameter);
// @@protoc_insertion_point(class_scope:paddle_mobile.framework.proto.OpDesc.Var)
private:
void set_has_parameter();
void clear_has_parameter();
::google::protobuf::internal::InternalMetadataWithArenaLite
_internal_metadata_;
::google::protobuf::internal::HasBits<1> _has_bits_;
mutable int _cached_size_;
::google::protobuf::RepeatedPtrField<::std::string> arguments_;
::google::protobuf::internal::ArenaStringPtr parameter_;
friend struct protobuf_framework_2eproto::TableStruct;
};
// -------------------------------------------------------------------
class OpDesc
: public ::google::protobuf::
MessageLite /* @@protoc_insertion_point(class_definition:paddle_mobile.framework.proto.OpDesc)
*/
{
public:
OpDesc();
virtual ~OpDesc();
OpDesc(const OpDesc &from);
inline OpDesc &operator=(const OpDesc &from) {
CopyFrom(from);
return *this;
}
#if LANG_CXX11
OpDesc(OpDesc &&from) noexcept : OpDesc() { *this = ::std::move(from); }
inline OpDesc &operator=(OpDesc &&from) noexcept {
if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
if (this != &from) InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
#endif
inline const ::std::string &unknown_fields() const {
return _internal_metadata_.unknown_fields();
}
inline ::std::string *mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields();
}
static const OpDesc &default_instance();
static inline const OpDesc *internal_default_instance() {
return reinterpret_cast<const OpDesc *>(&_OpDesc_default_instance_);
}
static PROTOBUF_CONSTEXPR int const kIndexInFileMessages = 2;
void Swap(OpDesc *other);
friend void swap(OpDesc &a, OpDesc &b) { a.Swap(&b); }
// implements Message
// ----------------------------------------------
inline OpDesc *New() const PROTOBUF_FINAL { return New(NULL); }
OpDesc *New(::google::protobuf::Arena *arena) const PROTOBUF_FINAL;
void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite &from)
PROTOBUF_FINAL;
void CopyFrom(const OpDesc &from);
void MergeFrom(const OpDesc &from);
void Clear() PROTOBUF_FINAL;
bool IsInitialized() const PROTOBUF_FINAL;
size_t ByteSizeLong() const PROTOBUF_FINAL;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream *input) PROTOBUF_FINAL;
void SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream *output) const PROTOBUF_FINAL;
void DiscardUnknownFields();
int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const;
void InternalSwap(OpDesc *other);
private:
inline ::google::protobuf::Arena *GetArenaNoVirtual() const { return NULL; }
inline void *MaybeArenaPtr() const { return NULL; }
public:
::std::string GetTypeName() const PROTOBUF_FINAL;
// nested types
// ----------------------------------------------------
typedef OpDesc_Attr Attr;
typedef OpDesc_Var Var;
// accessors
// -------------------------------------------------------
// repeated .paddle_mobile.framework.proto.OpDesc.Var inputs =
// 1;
int inputs_size() const;
void clear_inputs();
static const int kInputsFieldNumber = 1;
const ::paddle_mobile::framework::proto::OpDesc_Var &inputs(int index) const;
::paddle_mobile::framework::proto::OpDesc_Var *mutable_inputs(int index);
::paddle_mobile::framework::proto::OpDesc_Var *add_inputs();
::google::protobuf::RepeatedPtrField<
::paddle_mobile::framework::proto::OpDesc_Var>
*mutable_inputs();
const ::google::protobuf::RepeatedPtrField<
::paddle_mobile::framework::proto::OpDesc_Var>
&inputs() const;
// repeated .paddle_mobile.framework.proto.OpDesc.Var outputs =
// 2;
int outputs_size() const;
void clear_outputs();
static const int kOutputsFieldNumber = 2;
const ::paddle_mobile::framework::proto::OpDesc_Var &outputs(int index) const;
::paddle_mobile::framework::proto::OpDesc_Var *mutable_outputs(int index);
::paddle_mobile::framework::proto::OpDesc_Var *add_outputs();
::google::protobuf::RepeatedPtrField<
::paddle_mobile::framework::proto::OpDesc_Var>
*mutable_outputs();
const ::google::protobuf::RepeatedPtrField<
::paddle_mobile::framework::proto::OpDesc_Var>
&outputs() const;
// repeated .paddle_mobile.framework.proto.OpDesc.Attr attrs =
// 4;
int attrs_size() const;
void clear_attrs();
static const int kAttrsFieldNumber = 4;
const ::paddle_mobile::framework::proto::OpDesc_Attr &attrs(int index) const;
::paddle_mobile::framework::proto::OpDesc_Attr *mutable_attrs(int index);
::paddle_mobile::framework::proto::OpDesc_Attr *add_attrs();
::google::protobuf::RepeatedPtrField<
::paddle_mobile::framework::proto::OpDesc_Attr>
*mutable_attrs();
const ::google::protobuf::RepeatedPtrField<
::paddle_mobile::framework::proto::OpDesc_Attr>
&attrs() const;
// required string type = 3;
bool has_type() const;
void clear_type();
static const int kTypeFieldNumber = 3;
const ::std::string &type() const;
void set_type(const ::std::string &value);
#if LANG_CXX11
void set_type(::std::string &&value);
#endif
void set_type(const char *value);
void set_type(const char *value, size_t size);
::std::string *mutable_type();
::std::string *release_type();
void set_allocated_type(::std::string *type);
// optional bool is_target = 5 [default = false];
bool has_is_target() const;
void clear_is_target();
static const int kIsTargetFieldNumber = 5;
bool is_target() const;
void set_is_target(bool value);
// @@protoc_insertion_point(class_scope:paddle_mobile.framework.proto.OpDesc)
private:
void set_has_type();
void clear_has_type();
void set_has_is_target();
void clear_has_is_target();
::google::protobuf::internal::InternalMetadataWithArenaLite
_internal_metadata_;
::google::protobuf::internal::HasBits<1> _has_bits_;
mutable int _cached_size_;
::google::protobuf::RepeatedPtrField<
::paddle_mobile::framework::proto::OpDesc_Var>
inputs_;
::google::protobuf::RepeatedPtrField<
::paddle_mobile::framework::proto::OpDesc_Var>
outputs_;
::google::protobuf::RepeatedPtrField<
::paddle_mobile::framework::proto::OpDesc_Attr>
attrs_;
::google::protobuf::internal::ArenaStringPtr type_;
bool is_target_;
friend struct protobuf_framework_2eproto::TableStruct;
};
// -------------------------------------------------------------------
class OpProto_Var
: public ::google::protobuf::
MessageLite /* @@protoc_insertion_point(class_definition:paddle_mobile.framework.proto.OpProto.Var)
*/
{
public:
OpProto_Var();
virtual ~OpProto_Var();
OpProto_Var(const OpProto_Var &from);
inline OpProto_Var &operator=(const OpProto_Var &from) {
CopyFrom(from);
return *this;
}
#if LANG_CXX11
OpProto_Var(OpProto_Var &&from) noexcept : OpProto_Var() {
*this = ::std::move(from);
}
inline OpProto_Var &operator=(OpProto_Var &&from) noexcept {
if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
if (this != &from) InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
#endif
inline const ::std::string &unknown_fields() const {
return _internal_metadata_.unknown_fields();
}
inline ::std::string *mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields();
}
static const OpProto_Var &default_instance();
static inline const OpProto_Var *internal_default_instance() {
return reinterpret_cast<const OpProto_Var *>(
&_OpProto_Var_default_instance_);
}
static PROTOBUF_CONSTEXPR int const kIndexInFileMessages = 3;
void Swap(OpProto_Var *other);
friend void swap(OpProto_Var &a, OpProto_Var &b) { a.Swap(&b); }
// implements Message
// ----------------------------------------------
inline OpProto_Var *New() const PROTOBUF_FINAL { return New(NULL); }
OpProto_Var *New(::google::protobuf::Arena *arena) const PROTOBUF_FINAL;
void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite &from)
PROTOBUF_FINAL;
void CopyFrom(const OpProto_Var &from);
void MergeFrom(const OpProto_Var &from);
void Clear() PROTOBUF_FINAL;
bool IsInitialized() const PROTOBUF_FINAL;
size_t ByteSizeLong() const PROTOBUF_FINAL;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream *input) PROTOBUF_FINAL;
void SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream *output) const PROTOBUF_FINAL;
void DiscardUnknownFields();
int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const;
void InternalSwap(OpProto_Var *other);
private:
inline ::google::protobuf::Arena *GetArenaNoVirtual() const { return NULL; }
inline void *MaybeArenaPtr() const { return NULL; }
public:
::std::string GetTypeName() const PROTOBUF_FINAL;
// nested types
// ----------------------------------------------------
// accessors
// -------------------------------------------------------
// required string name = 1;
bool has_name() const;
void clear_name();
static const int kNameFieldNumber = 1;
const ::std::string &name() const;
void set_name(const ::std::string &value);
#if LANG_CXX11
void set_name(::std::string &&value);
#endif
void set_name(const char *value);
void set_name(const char *value, size_t size);
::std::string *mutable_name();
::std::string *release_name();
void set_allocated_name(::std::string *name);
// required string comment = 2;
bool has_comment() const;
void clear_comment();
static const int kCommentFieldNumber = 2;
const ::std::string &comment() const;
void set_comment(const ::std::string &value);
#if LANG_CXX11
void set_comment(::std::string &&value);
#endif
void set_comment(const char *value);
void set_comment(const char *value, size_t size);
::std::string *mutable_comment();
::std::string *release_comment();
void set_allocated_comment(::std::string *comment);
// optional bool duplicable = 3 [default = false];
bool has_duplicable() const;
void clear_duplicable();
static const int kDuplicableFieldNumber = 3;
bool duplicable() const;
void set_duplicable(bool value);
// optional bool intermediate = 4 [default = false];
bool has_intermediate() const;
void clear_intermediate();
static const int kIntermediateFieldNumber = 4;
bool intermediate() const;
void set_intermediate(bool value);
// optional bool dispensable = 5 [default = false];
bool has_dispensable() const;
void clear_dispensable();
static const int kDispensableFieldNumber = 5;
bool dispensable() const;
void set_dispensable(bool value);
// @@protoc_insertion_point(class_scope:paddle_mobile.framework.proto.OpProto.Var)
private:
void set_has_name();
void clear_has_name();
void set_has_comment();
void clear_has_comment();
void set_has_duplicable();
void clear_has_duplicable();
void set_has_intermediate();
void clear_has_intermediate();
void set_has_dispensable();
void clear_has_dispensable();
// helper for ByteSizeLong()
size_t RequiredFieldsByteSizeFallback() const;
::google::protobuf::internal::InternalMetadataWithArenaLite
_internal_metadata_;
::google::protobuf::internal::HasBits<1> _has_bits_;
mutable int _cached_size_;
::google::protobuf::internal::ArenaStringPtr name_;
::google::protobuf::internal::ArenaStringPtr comment_;
bool duplicable_;
bool intermediate_;
bool dispensable_;
friend struct protobuf_framework_2eproto::TableStruct;
};
// -------------------------------------------------------------------
class OpProto_Attr
: public ::google::protobuf::
MessageLite /* @@protoc_insertion_point(class_definition:paddle_mobile.framework.proto.OpProto.Attr)
*/
{
public:
OpProto_Attr();
virtual ~OpProto_Attr();
OpProto_Attr(const OpProto_Attr &from);
inline OpProto_Attr &operator=(const OpProto_Attr &from) {
CopyFrom(from);
return *this;
}
#if LANG_CXX11
OpProto_Attr(OpProto_Attr &&from) noexcept : OpProto_Attr() {
*this = ::std::move(from);
}
inline OpProto_Attr &operator=(OpProto_Attr &&from) noexcept {
if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
if (this != &from) InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
#endif
inline const ::std::string &unknown_fields() const {
return _internal_metadata_.unknown_fields();
}
inline ::std::string *mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields();
}
static const OpProto_Attr &default_instance();
static inline const OpProto_Attr *internal_default_instance() {
return reinterpret_cast<const OpProto_Attr *>(
&_OpProto_Attr_default_instance_);
}
static PROTOBUF_CONSTEXPR int const kIndexInFileMessages = 4;
void Swap(OpProto_Attr *other);
friend void swap(OpProto_Attr &a, OpProto_Attr &b) { a.Swap(&b); }
// implements Message
// ----------------------------------------------
inline OpProto_Attr *New() const PROTOBUF_FINAL { return New(NULL); }
OpProto_Attr *New(::google::protobuf::Arena *arena) const PROTOBUF_FINAL;
void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite &from)
PROTOBUF_FINAL;
void CopyFrom(const OpProto_Attr &from);
void MergeFrom(const OpProto_Attr &from);
void Clear() PROTOBUF_FINAL;
bool IsInitialized() const PROTOBUF_FINAL;
size_t ByteSizeLong() const PROTOBUF_FINAL;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream *input) PROTOBUF_FINAL;
void SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream *output) const PROTOBUF_FINAL;
void DiscardUnknownFields();
int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const;
void InternalSwap(OpProto_Attr *other);
private:
inline ::google::protobuf::Arena *GetArenaNoVirtual() const { return NULL; }
inline void *MaybeArenaPtr() const { return NULL; }
public:
::std::string GetTypeName() const PROTOBUF_FINAL;
// nested types
// ----------------------------------------------------
// accessors
// -------------------------------------------------------
// required string name = 1;
bool has_name() const;
void clear_name();
static const int kNameFieldNumber = 1;
const ::std::string &name() const;
void set_name(const ::std::string &value);
#if LANG_CXX11
void set_name(::std::string &&value);
#endif
void set_name(const char *value);
void set_name(const char *value, size_t size);
::std::string *mutable_name();
::std::string *release_name();
void set_allocated_name(::std::string *name);
// required string comment = 3;
bool has_comment() const;
void clear_comment();
static const int kCommentFieldNumber = 3;
const ::std::string &comment() const;
void set_comment(const ::std::string &value);
#if LANG_CXX11
void set_comment(::std::string &&value);
#endif
void set_comment(const char *value);
void set_comment(const char *value, size_t size);
::std::string *mutable_comment();
::std::string *release_comment();
void set_allocated_comment(::std::string *comment);
// required .paddle_mobile.framework.proto.AttrType type = 2;
bool has_type() const;
void clear_type();
static const int kTypeFieldNumber = 2;
::paddle_mobile::framework::proto::AttrType type() const;
void set_type(::paddle_mobile::framework::proto::AttrType value);
// optional bool generated = 4 [default = false];
bool has_generated() const;
void clear_generated();
static const int kGeneratedFieldNumber = 4;
bool generated() const;
void set_generated(bool value);
// @@protoc_insertion_point(class_scope:paddle_mobile.framework.proto.OpProto.Attr)
private:
void set_has_name();
void clear_has_name();
void set_has_type();
void clear_has_type();
void set_has_comment();
void clear_has_comment();
void set_has_generated();
void clear_has_generated();
// helper for ByteSizeLong()
size_t RequiredFieldsByteSizeFallback() const;
::google::protobuf::internal::InternalMetadataWithArenaLite
_internal_metadata_;
::google::protobuf::internal::HasBits<1> _has_bits_;
mutable int _cached_size_;
::google::protobuf::internal::ArenaStringPtr name_;
::google::protobuf::internal::ArenaStringPtr comment_;
int type_;
bool generated_;
friend struct protobuf_framework_2eproto::TableStruct;
};
// -------------------------------------------------------------------
class OpProto
: public ::google::protobuf::
MessageLite /* @@protoc_insertion_point(class_definition:paddle_mobile.framework.proto.OpProto)
*/
{
public:
OpProto();
virtual ~OpProto();
OpProto(const OpProto &from);
inline OpProto &operator=(const OpProto &from) {
CopyFrom(from);
return *this;
}
#if LANG_CXX11
OpProto(OpProto &&from) noexcept : OpProto() { *this = ::std::move(from); }
inline OpProto &operator=(OpProto &&from) noexcept {
if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
if (this != &from) InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
#endif
inline const ::std::string &unknown_fields() const {
return _internal_metadata_.unknown_fields();
}
inline ::std::string *mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields();
}
static const OpProto &default_instance();
static inline const OpProto *internal_default_instance() {
return reinterpret_cast<const OpProto *>(&_OpProto_default_instance_);
}
static PROTOBUF_CONSTEXPR int const kIndexInFileMessages = 5;
void Swap(OpProto *other);
friend void swap(OpProto &a, OpProto &b) { a.Swap(&b); }
// implements Message
// ----------------------------------------------
inline OpProto *New() const PROTOBUF_FINAL { return New(NULL); }
OpProto *New(::google::protobuf::Arena *arena) const PROTOBUF_FINAL;
void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite &from)
PROTOBUF_FINAL;
void CopyFrom(const OpProto &from);
void MergeFrom(const OpProto &from);
void Clear() PROTOBUF_FINAL;
bool IsInitialized() const PROTOBUF_FINAL;
size_t ByteSizeLong() const PROTOBUF_FINAL;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream *input) PROTOBUF_FINAL;
void SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream *output) const PROTOBUF_FINAL;
void DiscardUnknownFields();
int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const;
void InternalSwap(OpProto *other);
private:
inline ::google::protobuf::Arena *GetArenaNoVirtual() const { return NULL; }
inline void *MaybeArenaPtr() const { return NULL; }
public:
::std::string GetTypeName() const PROTOBUF_FINAL;
// nested types
// ----------------------------------------------------
typedef OpProto_Var Var;
typedef OpProto_Attr Attr;
// accessors
// -------------------------------------------------------
// repeated .paddle_mobile.framework.proto.OpProto.Var inputs =
// 2;
int inputs_size() const;
void clear_inputs();
static const int kInputsFieldNumber = 2;
const ::paddle_mobile::framework::proto::OpProto_Var &inputs(int index) const;
::paddle_mobile::framework::proto::OpProto_Var *mutable_inputs(int index);
::paddle_mobile::framework::proto::OpProto_Var *add_inputs();
::google::protobuf::RepeatedPtrField<
::paddle_mobile::framework::proto::OpProto_Var>
*mutable_inputs();
const ::google::protobuf::RepeatedPtrField<
::paddle_mobile::framework::proto::OpProto_Var>
&inputs() const;
// repeated .paddle_mobile.framework.proto.OpProto.Var outputs =
// 3;
int outputs_size() const;
void clear_outputs();
static const int kOutputsFieldNumber = 3;
const ::paddle_mobile::framework::proto::OpProto_Var &outputs(
int index) const;
::paddle_mobile::framework::proto::OpProto_Var *mutable_outputs(int index);
::paddle_mobile::framework::proto::OpProto_Var *add_outputs();
::google::protobuf::RepeatedPtrField<
::paddle_mobile::framework::proto::OpProto_Var>
*mutable_outputs();
const ::google::protobuf::RepeatedPtrField<
::paddle_mobile::framework::proto::OpProto_Var>
&outputs() const;
// repeated .paddle_mobile.framework.proto.OpProto.Attr attrs =
// 4;
int attrs_size() const;
void clear_attrs();
static const int kAttrsFieldNumber = 4;
const ::paddle_mobile::framework::proto::OpProto_Attr &attrs(int index) const;
::paddle_mobile::framework::proto::OpProto_Attr *mutable_attrs(int index);
::paddle_mobile::framework::proto::OpProto_Attr *add_attrs();
::google::protobuf::RepeatedPtrField<
::paddle_mobile::framework::proto::OpProto_Attr>
*mutable_attrs();
const ::google::protobuf::RepeatedPtrField<
::paddle_mobile::framework::proto::OpProto_Attr>
&attrs() const;
// required string type = 1;
bool has_type() const;
void clear_type();
static const int kTypeFieldNumber = 1;
const ::std::string &type() const;
void set_type(const ::std::string &value);
#if LANG_CXX11
void set_type(::std::string &&value);
#endif
void set_type(const char *value);
void set_type(const char *value, size_t size);
::std::string *mutable_type();
::std::string *release_type();
void set_allocated_type(::std::string *type);
// required string comment = 5;
bool has_comment() const;
void clear_comment();
static const int kCommentFieldNumber = 5;
const ::std::string &comment() const;
void set_comment(const ::std::string &value);
#if LANG_CXX11
void set_comment(::std::string &&value);
#endif
void set_comment(const char *value);
void set_comment(const char *value, size_t size);
::std::string *mutable_comment();
::std::string *release_comment();
void set_allocated_comment(::std::string *comment);
// @@protoc_insertion_point(class_scope:paddle_mobile.framework.proto.OpProto)
private:
void set_has_type();
void clear_has_type();
void set_has_comment();
void clear_has_comment();
// helper for ByteSizeLong()
size_t RequiredFieldsByteSizeFallback() const;
::google::protobuf::internal::InternalMetadataWithArenaLite
_internal_metadata_;
::google::protobuf::internal::HasBits<1> _has_bits_;
mutable int _cached_size_;
::google::protobuf::RepeatedPtrField<
::paddle_mobile::framework::proto::OpProto_Var>
inputs_;
::google::protobuf::RepeatedPtrField<
::paddle_mobile::framework::proto::OpProto_Var>
outputs_;
::google::protobuf::RepeatedPtrField<
::paddle_mobile::framework::proto::OpProto_Attr>
attrs_;
::google::protobuf::internal::ArenaStringPtr type_;
::google::protobuf::internal::ArenaStringPtr comment_;
friend struct protobuf_framework_2eproto::TableStruct;
};
// -------------------------------------------------------------------
class VarType_TensorDesc
: public ::google::protobuf::
MessageLite /* @@protoc_insertion_point(class_definition:paddle_mobile.framework.proto.VarType.TensorDesc)
*/
{
public:
VarType_TensorDesc();
virtual ~VarType_TensorDesc();
VarType_TensorDesc(const VarType_TensorDesc &from);
inline VarType_TensorDesc &operator=(const VarType_TensorDesc &from) {
CopyFrom(from);
return *this;
}
#if LANG_CXX11
VarType_TensorDesc(VarType_TensorDesc &&from) noexcept
: VarType_TensorDesc() {
*this = ::std::move(from);
}
inline VarType_TensorDesc &operator=(VarType_TensorDesc &&from) noexcept {
if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
if (this != &from) InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
#endif
inline const ::std::string &unknown_fields() const {
return _internal_metadata_.unknown_fields();
}
inline ::std::string *mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields();
}
static const VarType_TensorDesc &default_instance();
static inline const VarType_TensorDesc *internal_default_instance() {
return reinterpret_cast<const VarType_TensorDesc *>(
&_VarType_TensorDesc_default_instance_);
}
static PROTOBUF_CONSTEXPR int const kIndexInFileMessages = 6;
void Swap(VarType_TensorDesc *other);
friend void swap(VarType_TensorDesc &a, VarType_TensorDesc &b) { a.Swap(&b); }
// implements Message
// ----------------------------------------------
inline VarType_TensorDesc *New() const PROTOBUF_FINAL { return New(NULL); }
VarType_TensorDesc *New(::google::protobuf::Arena *arena) const
PROTOBUF_FINAL;
void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite &from)
PROTOBUF_FINAL;
void CopyFrom(const VarType_TensorDesc &from);
void MergeFrom(const VarType_TensorDesc &from);
void Clear() PROTOBUF_FINAL;
bool IsInitialized() const PROTOBUF_FINAL;
size_t ByteSizeLong() const PROTOBUF_FINAL;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream *input) PROTOBUF_FINAL;
void SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream *output) const PROTOBUF_FINAL;
void DiscardUnknownFields();
int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const;
void InternalSwap(VarType_TensorDesc *other);
private:
inline ::google::protobuf::Arena *GetArenaNoVirtual() const { return NULL; }
inline void *MaybeArenaPtr() const { return NULL; }
public:
::std::string GetTypeName() const PROTOBUF_FINAL;
// nested types
// ----------------------------------------------------
// accessors
// -------------------------------------------------------
// repeated int64 dims = 2;
int dims_size() const;
void clear_dims();
static const int kDimsFieldNumber = 2;
::google::protobuf::int64 dims(int index) const;
void set_dims(int index, ::google::protobuf::int64 value);
void add_dims(::google::protobuf::int64 value);
const ::google::protobuf::RepeatedField<::google::protobuf::int64> &dims()
const;
::google::protobuf::RepeatedField<::google::protobuf::int64> *mutable_dims();
// required .paddle_mobile.framework.proto.VarType.Type
// data_type = 1;
bool has_data_type() const;
void clear_data_type();
static const int kDataTypeFieldNumber = 1;
::paddle_mobile::framework::proto::VarType_Type data_type() const;
void set_data_type(::paddle_mobile::framework::proto::VarType_Type value);
// @@protoc_insertion_point(class_scope:paddle_mobile.framework.proto.VarType.TensorDesc)
private:
void set_has_data_type();
void clear_has_data_type();
::google::protobuf::internal::InternalMetadataWithArenaLite
_internal_metadata_;
::google::protobuf::internal::HasBits<1> _has_bits_;
mutable int _cached_size_;
::google::protobuf::RepeatedField<::google::protobuf::int64> dims_;
int data_type_;
friend struct protobuf_framework_2eproto::TableStruct;
};
// -------------------------------------------------------------------
class VarType_LoDTensorDesc
: public ::google::protobuf::
MessageLite /* @@protoc_insertion_point(class_definition:paddle_mobile.framework.proto.VarType.LoDTensorDesc)
*/
{
public:
VarType_LoDTensorDesc();
virtual ~VarType_LoDTensorDesc();
VarType_LoDTensorDesc(const VarType_LoDTensorDesc &from);
inline VarType_LoDTensorDesc &operator=(const VarType_LoDTensorDesc &from) {
CopyFrom(from);
return *this;
}
#if LANG_CXX11
VarType_LoDTensorDesc(VarType_LoDTensorDesc &&from) noexcept
: VarType_LoDTensorDesc() {
*this = ::std::move(from);
}
inline VarType_LoDTensorDesc &operator=(
VarType_LoDTensorDesc &&from) noexcept {
if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
if (this != &from) InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
#endif
inline const ::std::string &unknown_fields() const {
return _internal_metadata_.unknown_fields();
}
inline ::std::string *mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields();
}
static const VarType_LoDTensorDesc &default_instance();
static inline const VarType_LoDTensorDesc *internal_default_instance() {
return reinterpret_cast<const VarType_LoDTensorDesc *>(
&_VarType_LoDTensorDesc_default_instance_);
}
static PROTOBUF_CONSTEXPR int const kIndexInFileMessages = 7;
void Swap(VarType_LoDTensorDesc *other);
friend void swap(VarType_LoDTensorDesc &a, VarType_LoDTensorDesc &b) {
a.Swap(&b);
}
// implements Message
// ----------------------------------------------
inline VarType_LoDTensorDesc *New() const PROTOBUF_FINAL { return New(NULL); }
VarType_LoDTensorDesc *New(::google::protobuf::Arena *arena) const
PROTOBUF_FINAL;
void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite &from)
PROTOBUF_FINAL;
void CopyFrom(const VarType_LoDTensorDesc &from);
void MergeFrom(const VarType_LoDTensorDesc &from);
void Clear() PROTOBUF_FINAL;
bool IsInitialized() const PROTOBUF_FINAL;
size_t ByteSizeLong() const PROTOBUF_FINAL;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream *input) PROTOBUF_FINAL;
void SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream *output) const PROTOBUF_FINAL;
void DiscardUnknownFields();
int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const;
void InternalSwap(VarType_LoDTensorDesc *other);
private:
inline ::google::protobuf::Arena *GetArenaNoVirtual() const { return NULL; }
inline void *MaybeArenaPtr() const { return NULL; }
public:
::std::string GetTypeName() const PROTOBUF_FINAL;
// nested types
// ----------------------------------------------------
// accessors
// -------------------------------------------------------
// required .paddle_mobile.framework.proto.VarType.TensorDesc
// tensor = 1;
bool has_tensor() const;
void clear_tensor();
static const int kTensorFieldNumber = 1;
const ::paddle_mobile::framework::proto::VarType_TensorDesc &tensor() const;
::paddle_mobile::framework::proto::VarType_TensorDesc *mutable_tensor();
::paddle_mobile::framework::proto::VarType_TensorDesc *release_tensor();
void set_allocated_tensor(
::paddle_mobile::framework::proto::VarType_TensorDesc *tensor);
// optional int32 lod_level = 2 [default = 0];
bool has_lod_level() const;
void clear_lod_level();
static const int kLodLevelFieldNumber = 2;
::google::protobuf::int32 lod_level() const;
void set_lod_level(::google::protobuf::int32 value);
// @@protoc_insertion_point(class_scope:paddle_mobile.framework.proto.VarType.LoDTensorDesc)
private:
void set_has_tensor();
void clear_has_tensor();
void set_has_lod_level();
void clear_has_lod_level();
::google::protobuf::internal::InternalMetadataWithArenaLite
_internal_metadata_;
::google::protobuf::internal::HasBits<1> _has_bits_;
mutable int _cached_size_;
::paddle_mobile::framework::proto::VarType_TensorDesc *tensor_;
::google::protobuf::int32 lod_level_;
friend struct protobuf_framework_2eproto::TableStruct;
};
// -------------------------------------------------------------------
class VarType_LoDTensorArrayDesc
: public ::google::protobuf::
MessageLite /* @@protoc_insertion_point(class_definition:paddle_mobile.framework.proto.VarType.LoDTensorArrayDesc)
*/
{
public:
VarType_LoDTensorArrayDesc();
virtual ~VarType_LoDTensorArrayDesc();
VarType_LoDTensorArrayDesc(const VarType_LoDTensorArrayDesc &from);
inline VarType_LoDTensorArrayDesc &operator=(
const VarType_LoDTensorArrayDesc &from) {
CopyFrom(from);
return *this;
}
#if LANG_CXX11
VarType_LoDTensorArrayDesc(VarType_LoDTensorArrayDesc &&from) noexcept
: VarType_LoDTensorArrayDesc() {
*this = ::std::move(from);
}
inline VarType_LoDTensorArrayDesc &operator=(
VarType_LoDTensorArrayDesc &&from) noexcept {
if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
if (this != &from) InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
#endif
inline const ::std::string &unknown_fields() const {
return _internal_metadata_.unknown_fields();
}
inline ::std::string *mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields();
}
static const VarType_LoDTensorArrayDesc &default_instance();
static inline const VarType_LoDTensorArrayDesc *internal_default_instance() {
return reinterpret_cast<const VarType_LoDTensorArrayDesc *>(
&_VarType_LoDTensorArrayDesc_default_instance_);
}
static PROTOBUF_CONSTEXPR int const kIndexInFileMessages = 8;
void Swap(VarType_LoDTensorArrayDesc *other);
friend void swap(VarType_LoDTensorArrayDesc &a,
VarType_LoDTensorArrayDesc &b) {
a.Swap(&b);
}
// implements Message
// ----------------------------------------------
inline VarType_LoDTensorArrayDesc *New() const PROTOBUF_FINAL {
return New(NULL);
}
VarType_LoDTensorArrayDesc *New(::google::protobuf::Arena *arena) const
PROTOBUF_FINAL;
void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite &from)
PROTOBUF_FINAL;
void CopyFrom(const VarType_LoDTensorArrayDesc &from);
void MergeFrom(const VarType_LoDTensorArrayDesc &from);
void Clear() PROTOBUF_FINAL;
bool IsInitialized() const PROTOBUF_FINAL;
size_t ByteSizeLong() const PROTOBUF_FINAL;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream *input) PROTOBUF_FINAL;
void SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream *output) const PROTOBUF_FINAL;
void DiscardUnknownFields();
int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const;
void InternalSwap(VarType_LoDTensorArrayDesc *other);
private:
inline ::google::protobuf::Arena *GetArenaNoVirtual() const { return NULL; }
inline void *MaybeArenaPtr() const { return NULL; }
public:
::std::string GetTypeName() const PROTOBUF_FINAL;
// nested types
// ----------------------------------------------------
// accessors
// -------------------------------------------------------
// required .paddle_mobile.framework.proto.VarType.TensorDesc
// tensor = 1;
bool has_tensor() const;
void clear_tensor();
static const int kTensorFieldNumber = 1;
const ::paddle_mobile::framework::proto::VarType_TensorDesc &tensor() const;
::paddle_mobile::framework::proto::VarType_TensorDesc *mutable_tensor();
::paddle_mobile::framework::proto::VarType_TensorDesc *release_tensor();
void set_allocated_tensor(
::paddle_mobile::framework::proto::VarType_TensorDesc *tensor);
// optional int32 lod_level = 2 [default = 0];
bool has_lod_level() const;
void clear_lod_level();
static const int kLodLevelFieldNumber = 2;
::google::protobuf::int32 lod_level() const;
void set_lod_level(::google::protobuf::int32 value);
// @@protoc_insertion_point(class_scope:paddle_mobile.framework.proto.VarType.LoDTensorArrayDesc)
private:
void set_has_tensor();
void clear_has_tensor();
void set_has_lod_level();
void clear_has_lod_level();
::google::protobuf::internal::InternalMetadataWithArenaLite
_internal_metadata_;
::google::protobuf::internal::HasBits<1> _has_bits_;
mutable int _cached_size_;
::paddle_mobile::framework::proto::VarType_TensorDesc *tensor_;
::google::protobuf::int32 lod_level_;
friend struct protobuf_framework_2eproto::TableStruct;
};
// -------------------------------------------------------------------
class VarType_ReaderDesc
: public ::google::protobuf::
MessageLite /* @@protoc_insertion_point(class_definition:paddle_mobile.framework.proto.VarType.ReaderDesc)
*/
{
public:
VarType_ReaderDesc();
virtual ~VarType_ReaderDesc();
VarType_ReaderDesc(const VarType_ReaderDesc &from);
inline VarType_ReaderDesc &operator=(const VarType_ReaderDesc &from) {
CopyFrom(from);
return *this;
}
#if LANG_CXX11
VarType_ReaderDesc(VarType_ReaderDesc &&from) noexcept
: VarType_ReaderDesc() {
*this = ::std::move(from);
}
inline VarType_ReaderDesc &operator=(VarType_ReaderDesc &&from) noexcept {
if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
if (this != &from) InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
#endif
inline const ::std::string &unknown_fields() const {
return _internal_metadata_.unknown_fields();
}
inline ::std::string *mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields();
}
static const VarType_ReaderDesc &default_instance();
static inline const VarType_ReaderDesc *internal_default_instance() {
return reinterpret_cast<const VarType_ReaderDesc *>(
&_VarType_ReaderDesc_default_instance_);
}
static PROTOBUF_CONSTEXPR int const kIndexInFileMessages = 9;
void Swap(VarType_ReaderDesc *other);
friend void swap(VarType_ReaderDesc &a, VarType_ReaderDesc &b) { a.Swap(&b); }
// implements Message
// ----------------------------------------------
inline VarType_ReaderDesc *New() const PROTOBUF_FINAL { return New(NULL); }
VarType_ReaderDesc *New(::google::protobuf::Arena *arena) const
PROTOBUF_FINAL;
void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite &from)
PROTOBUF_FINAL;
void CopyFrom(const VarType_ReaderDesc &from);
void MergeFrom(const VarType_ReaderDesc &from);
void Clear() PROTOBUF_FINAL;
bool IsInitialized() const PROTOBUF_FINAL;
size_t ByteSizeLong() const PROTOBUF_FINAL;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream *input) PROTOBUF_FINAL;
void SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream *output) const PROTOBUF_FINAL;
void DiscardUnknownFields();
int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const;
void InternalSwap(VarType_ReaderDesc *other);
private:
inline ::google::protobuf::Arena *GetArenaNoVirtual() const { return NULL; }
inline void *MaybeArenaPtr() const { return NULL; }
public:
::std::string GetTypeName() const PROTOBUF_FINAL;
// nested types
// ----------------------------------------------------
// accessors
// -------------------------------------------------------
// repeated .paddle_mobile.framework.proto.VarType.LoDTensorDesc
// lod_tensor =
// 1;
int lod_tensor_size() const;
void clear_lod_tensor();
static const int kLodTensorFieldNumber = 1;
const ::paddle_mobile::framework::proto::VarType_LoDTensorDesc &lod_tensor(
int index) const;
::paddle_mobile::framework::proto::VarType_LoDTensorDesc *mutable_lod_tensor(
int index);
::paddle_mobile::framework::proto::VarType_LoDTensorDesc *add_lod_tensor();
::google::protobuf::RepeatedPtrField<
::paddle_mobile::framework::proto::VarType_LoDTensorDesc>
*mutable_lod_tensor();
const ::google::protobuf::RepeatedPtrField<
::paddle_mobile::framework::proto::VarType_LoDTensorDesc>
&lod_tensor() const;
// @@protoc_insertion_point(class_scope:paddle_mobile.framework.proto.VarType.ReaderDesc)
private:
::google::protobuf::internal::InternalMetadataWithArenaLite
_internal_metadata_;
::google::protobuf::internal::HasBits<1> _has_bits_;
mutable int _cached_size_;
::google::protobuf::RepeatedPtrField<
::paddle_mobile::framework::proto::VarType_LoDTensorDesc>
lod_tensor_;
friend struct protobuf_framework_2eproto::TableStruct;
};
// -------------------------------------------------------------------
class VarType_ChannelDesc
: public ::google::protobuf::
MessageLite /* @@protoc_insertion_point(class_definition:paddle_mobile.framework.proto.VarType.ChannelDesc)
*/
{
public:
VarType_ChannelDesc();
virtual ~VarType_ChannelDesc();
VarType_ChannelDesc(const VarType_ChannelDesc &from);
inline VarType_ChannelDesc &operator=(const VarType_ChannelDesc &from) {
CopyFrom(from);
return *this;
}
#if LANG_CXX11
VarType_ChannelDesc(VarType_ChannelDesc &&from) noexcept
: VarType_ChannelDesc() {
*this = ::std::move(from);
}
inline VarType_ChannelDesc &operator=(VarType_ChannelDesc &&from) noexcept {
if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
if (this != &from) InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
#endif
inline const ::std::string &unknown_fields() const {
return _internal_metadata_.unknown_fields();
}
inline ::std::string *mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields();
}
static const VarType_ChannelDesc &default_instance();
static inline const VarType_ChannelDesc *internal_default_instance() {
return reinterpret_cast<const VarType_ChannelDesc *>(
&_VarType_ChannelDesc_default_instance_);
}
static PROTOBUF_CONSTEXPR int const kIndexInFileMessages = 10;
void Swap(VarType_ChannelDesc *other);
friend void swap(VarType_ChannelDesc &a, VarType_ChannelDesc &b) {
a.Swap(&b);
}
// implements Message
// ----------------------------------------------
inline VarType_ChannelDesc *New() const PROTOBUF_FINAL { return New(NULL); }
VarType_ChannelDesc *New(::google::protobuf::Arena *arena) const
PROTOBUF_FINAL;
void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite &from)
PROTOBUF_FINAL;
void CopyFrom(const VarType_ChannelDesc &from);
void MergeFrom(const VarType_ChannelDesc &from);
void Clear() PROTOBUF_FINAL;
bool IsInitialized() const PROTOBUF_FINAL;
size_t ByteSizeLong() const PROTOBUF_FINAL;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream *input) PROTOBUF_FINAL;
void SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream *output) const PROTOBUF_FINAL;
void DiscardUnknownFields();
int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const;
void InternalSwap(VarType_ChannelDesc *other);
private:
inline ::google::protobuf::Arena *GetArenaNoVirtual() const { return NULL; }
inline void *MaybeArenaPtr() const { return NULL; }
public:
::std::string GetTypeName() const PROTOBUF_FINAL;
// nested types
// ----------------------------------------------------
// accessors
// -------------------------------------------------------
// required int64 capacity = 2;
bool has_capacity() const;
void clear_capacity();
static const int kCapacityFieldNumber = 2;
::google::protobuf::int64 capacity() const;
void set_capacity(::google::protobuf::int64 value);
// required .paddle_mobile.framework.proto.VarType.Type
// data_type = 1;
bool has_data_type() const;
void clear_data_type();
static const int kDataTypeFieldNumber = 1;
::paddle_mobile::framework::proto::VarType_Type data_type() const;
void set_data_type(::paddle_mobile::framework::proto::VarType_Type value);
// @@protoc_insertion_point(class_scope:paddle_mobile.framework.proto.VarType.ChannelDesc)
private:
void set_has_data_type();
void clear_has_data_type();
void set_has_capacity();
void clear_has_capacity();
// helper for ByteSizeLong()
size_t RequiredFieldsByteSizeFallback() const;
::google::protobuf::internal::InternalMetadataWithArenaLite
_internal_metadata_;
::google::protobuf::internal::HasBits<1> _has_bits_;
mutable int _cached_size_;
::google::protobuf::int64 capacity_;
int data_type_;
friend struct protobuf_framework_2eproto::TableStruct;
};
// -------------------------------------------------------------------
class VarType_Tuple
: public ::google::protobuf::
MessageLite /* @@protoc_insertion_point(class_definition:paddle_mobile.framework.proto.VarType.Tuple)
*/
{
public:
VarType_Tuple();
virtual ~VarType_Tuple();
VarType_Tuple(const VarType_Tuple &from);
inline VarType_Tuple &operator=(const VarType_Tuple &from) {
CopyFrom(from);
return *this;
}
#if LANG_CXX11
VarType_Tuple(VarType_Tuple &&from) noexcept : VarType_Tuple() {
*this = ::std::move(from);
}
inline VarType_Tuple &operator=(VarType_Tuple &&from) noexcept {
if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
if (this != &from) InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
#endif
inline const ::std::string &unknown_fields() const {
return _internal_metadata_.unknown_fields();
}
inline ::std::string *mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields();
}
static const VarType_Tuple &default_instance();
static inline const VarType_Tuple *internal_default_instance() {
return reinterpret_cast<const VarType_Tuple *>(
&_VarType_Tuple_default_instance_);
}
static PROTOBUF_CONSTEXPR int const kIndexInFileMessages = 11;
void Swap(VarType_Tuple *other);
friend void swap(VarType_Tuple &a, VarType_Tuple &b) { a.Swap(&b); }
// implements Message
// ----------------------------------------------
inline VarType_Tuple *New() const PROTOBUF_FINAL { return New(NULL); }
VarType_Tuple *New(::google::protobuf::Arena *arena) const PROTOBUF_FINAL;
void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite &from)
PROTOBUF_FINAL;
void CopyFrom(const VarType_Tuple &from);
void MergeFrom(const VarType_Tuple &from);
void Clear() PROTOBUF_FINAL;
bool IsInitialized() const PROTOBUF_FINAL;
size_t ByteSizeLong() const PROTOBUF_FINAL;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream *input) PROTOBUF_FINAL;
void SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream *output) const PROTOBUF_FINAL;
void DiscardUnknownFields();
int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const;
void InternalSwap(VarType_Tuple *other);
private:
inline ::google::protobuf::Arena *GetArenaNoVirtual() const { return NULL; }
inline void *MaybeArenaPtr() const { return NULL; }
public:
::std::string GetTypeName() const PROTOBUF_FINAL;
// nested types
// ----------------------------------------------------
// accessors
// -------------------------------------------------------
// repeated .paddle_mobile.framework.proto.VarType.Type
// element_type = 1;
int element_type_size() const;
void clear_element_type();
static const int kElementTypeFieldNumber = 1;
::paddle_mobile::framework::proto::VarType_Type element_type(int index) const;
void set_element_type(int index,
::paddle_mobile::framework::proto::VarType_Type value);
void add_element_type(::paddle_mobile::framework::proto::VarType_Type value);
const ::google::protobuf::RepeatedField<int> &element_type() const;
::google::protobuf::RepeatedField<int> *mutable_element_type();
// @@protoc_insertion_point(class_scope:paddle_mobile.framework.proto.VarType.Tuple)
private:
::google::protobuf::internal::InternalMetadataWithArenaLite
_internal_metadata_;
::google::protobuf::internal::HasBits<1> _has_bits_;
mutable int _cached_size_;
::google::protobuf::RepeatedField<int> element_type_;
friend struct protobuf_framework_2eproto::TableStruct;
};
// -------------------------------------------------------------------
class VarType
: public ::google::protobuf::
MessageLite /* @@protoc_insertion_point(class_definition:paddle_mobile.framework.proto.VarType)
*/
{
public:
VarType();
virtual ~VarType();
VarType(const VarType &from);
inline VarType &operator=(const VarType &from) {
CopyFrom(from);
return *this;
}
#if LANG_CXX11
VarType(VarType &&from) noexcept : VarType() { *this = ::std::move(from); }
inline VarType &operator=(VarType &&from) noexcept {
if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
if (this != &from) InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
#endif
inline const ::std::string &unknown_fields() const {
return _internal_metadata_.unknown_fields();
}
inline ::std::string *mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields();
}
static const VarType &default_instance();
static inline const VarType *internal_default_instance() {
return reinterpret_cast<const VarType *>(&_VarType_default_instance_);
}
static PROTOBUF_CONSTEXPR int const kIndexInFileMessages = 12;
void Swap(VarType *other);
friend void swap(VarType &a, VarType &b) { a.Swap(&b); }
// implements Message
// ----------------------------------------------
inline VarType *New() const PROTOBUF_FINAL { return New(NULL); }
VarType *New(::google::protobuf::Arena *arena) const PROTOBUF_FINAL;
void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite &from)
PROTOBUF_FINAL;
void CopyFrom(const VarType &from);
void MergeFrom(const VarType &from);
void Clear() PROTOBUF_FINAL;
bool IsInitialized() const PROTOBUF_FINAL;
size_t ByteSizeLong() const PROTOBUF_FINAL;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream *input) PROTOBUF_FINAL;
void SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream *output) const PROTOBUF_FINAL;
void DiscardUnknownFields();
int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const;
void InternalSwap(VarType *other);
private:
inline ::google::protobuf::Arena *GetArenaNoVirtual() const { return NULL; }
inline void *MaybeArenaPtr() const { return NULL; }
public:
::std::string GetTypeName() const PROTOBUF_FINAL;
// nested types
// ----------------------------------------------------
typedef VarType_TensorDesc TensorDesc;
typedef VarType_LoDTensorDesc LoDTensorDesc;
typedef VarType_LoDTensorArrayDesc LoDTensorArrayDesc;
typedef VarType_ReaderDesc ReaderDesc;
typedef VarType_ChannelDesc ChannelDesc;
typedef VarType_Tuple Tuple;
typedef VarType_Type Type;
static const Type BOOL = VarType_Type_BOOL;
static const Type INT16 = VarType_Type_INT16;
static const Type INT32 = VarType_Type_INT32;
static const Type INT64 = VarType_Type_INT64;
static const Type FP16 = VarType_Type_FP16;
static const Type FP32 = VarType_Type_FP32;
static const Type FP64 = VarType_Type_FP64;
static const Type LOD_TENSOR = VarType_Type_LOD_TENSOR;
static const Type SELECTED_ROWS = VarType_Type_SELECTED_ROWS;
static const Type FEED_MINIBATCH = VarType_Type_FEED_MINIBATCH;
static const Type FETCH_LIST = VarType_Type_FETCH_LIST;
static const Type STEP_SCOPES = VarType_Type_STEP_SCOPES;
static const Type LOD_RANK_TABLE = VarType_Type_LOD_RANK_TABLE;
static const Type LOD_TENSOR_ARRAY = VarType_Type_LOD_TENSOR_ARRAY;
static const Type PLACE_LIST = VarType_Type_PLACE_LIST;
static const Type READER = VarType_Type_READER;
static const Type CHANNEL = VarType_Type_CHANNEL;
static const Type RAW = VarType_Type_RAW;
static const Type TUPLE = VarType_Type_TUPLE;
static inline bool Type_IsValid(int value) {
return VarType_Type_IsValid(value);
}
static const Type Type_MIN = VarType_Type_Type_MIN;
static const Type Type_MAX = VarType_Type_Type_MAX;
static const int Type_ARRAYSIZE = VarType_Type_Type_ARRAYSIZE;
// accessors
// -------------------------------------------------------
// optional .paddle_mobile.framework.proto.VarType.TensorDesc
// selected_rows =
// 2;
bool has_selected_rows() const;
void clear_selected_rows();
static const int kSelectedRowsFieldNumber = 2;
const ::paddle_mobile::framework::proto::VarType_TensorDesc &selected_rows()
const;
::paddle_mobile::framework::proto::VarType_TensorDesc *
mutable_selected_rows();
::paddle_mobile::framework::proto::VarType_TensorDesc *
release_selected_rows();
void set_allocated_selected_rows(
::paddle_mobile::framework::proto::VarType_TensorDesc *selected_rows);
// optional .paddle_mobile.framework.proto.VarType.LoDTensorDesc
// lod_tensor =
// 3;
bool has_lod_tensor() const;
void clear_lod_tensor();
static const int kLodTensorFieldNumber = 3;
const ::paddle_mobile::framework::proto::VarType_LoDTensorDesc &lod_tensor()
const;
::paddle_mobile::framework::proto::VarType_LoDTensorDesc *
mutable_lod_tensor();
::paddle_mobile::framework::proto::VarType_LoDTensorDesc *
release_lod_tensor();
void set_allocated_lod_tensor(
::paddle_mobile::framework::proto::VarType_LoDTensorDesc *lod_tensor);
// optional
// .paddle_mobile.framework.proto.VarType.LoDTensorArrayDesc
// tensor_array = 4;
bool has_tensor_array() const;
void clear_tensor_array();
static const int kTensorArrayFieldNumber = 4;
const ::paddle_mobile::framework::proto::VarType_LoDTensorArrayDesc &
tensor_array() const;
::paddle_mobile::framework::proto::VarType_LoDTensorArrayDesc *
mutable_tensor_array();
::paddle_mobile::framework::proto::VarType_LoDTensorArrayDesc *
release_tensor_array();
void set_allocated_tensor_array(
::paddle_mobile::framework::proto::VarType_LoDTensorArrayDesc
*tensor_array);
// optional .paddle_mobile.framework.proto.VarType.ReaderDesc
// reader = 5;
bool has_reader() const;
void clear_reader();
static const int kReaderFieldNumber = 5;
const ::paddle_mobile::framework::proto::VarType_ReaderDesc &reader() const;
::paddle_mobile::framework::proto::VarType_ReaderDesc *mutable_reader();
::paddle_mobile::framework::proto::VarType_ReaderDesc *release_reader();
void set_allocated_reader(
::paddle_mobile::framework::proto::VarType_ReaderDesc *reader);
// optional .paddle_mobile.framework.proto.VarType.ChannelDesc
// channel = 6;
bool has_channel() const;
void clear_channel();
static const int kChannelFieldNumber = 6;
const ::paddle_mobile::framework::proto::VarType_ChannelDesc &channel() const;
::paddle_mobile::framework::proto::VarType_ChannelDesc *mutable_channel();
::paddle_mobile::framework::proto::VarType_ChannelDesc *release_channel();
void set_allocated_channel(
::paddle_mobile::framework::proto::VarType_ChannelDesc *channel);
// optional .paddle_mobile.framework.proto.VarType.Tuple tuple =
// 7;
bool has_tuple() const;
void clear_tuple();
static const int kTupleFieldNumber = 7;
const ::paddle_mobile::framework::proto::VarType_Tuple &tuple() const;
::paddle_mobile::framework::proto::VarType_Tuple *mutable_tuple();
::paddle_mobile::framework::proto::VarType_Tuple *release_tuple();
void set_allocated_tuple(
::paddle_mobile::framework::proto::VarType_Tuple *tuple);
// required .paddle_mobile.framework.proto.VarType.Type type =
// 1;
bool has_type() const;
void clear_type();
static const int kTypeFieldNumber = 1;
::paddle_mobile::framework::proto::VarType_Type type() const;
void set_type(::paddle_mobile::framework::proto::VarType_Type value);
// @@protoc_insertion_point(class_scope:paddle_mobile.framework.proto.VarType)
private:
void set_has_type();
void clear_has_type();
void set_has_selected_rows();
void clear_has_selected_rows();
void set_has_lod_tensor();
void clear_has_lod_tensor();
void set_has_tensor_array();
void clear_has_tensor_array();
void set_has_reader();
void clear_has_reader();
void set_has_channel();
void clear_has_channel();
void set_has_tuple();
void clear_has_tuple();
::google::protobuf::internal::InternalMetadataWithArenaLite
_internal_metadata_;
::google::protobuf::internal::HasBits<1> _has_bits_;
mutable int _cached_size_;
::paddle_mobile::framework::proto::VarType_TensorDesc *selected_rows_;
::paddle_mobile::framework::proto::VarType_LoDTensorDesc *lod_tensor_;
::paddle_mobile::framework::proto::VarType_LoDTensorArrayDesc *tensor_array_;
::paddle_mobile::framework::proto::VarType_ReaderDesc *reader_;
::paddle_mobile::framework::proto::VarType_ChannelDesc *channel_;
::paddle_mobile::framework::proto::VarType_Tuple *tuple_;
int type_;
friend struct protobuf_framework_2eproto::TableStruct;
};
// -------------------------------------------------------------------
class VarDesc
: public ::google::protobuf::
MessageLite /* @@protoc_insertion_point(class_definition:paddle_mobile.framework.proto.VarDesc)
*/
{
public:
VarDesc();
virtual ~VarDesc();
VarDesc(const VarDesc &from);
inline VarDesc &operator=(const VarDesc &from) {
CopyFrom(from);
return *this;
}
#if LANG_CXX11
VarDesc(VarDesc &&from) noexcept : VarDesc() { *this = ::std::move(from); }
inline VarDesc &operator=(VarDesc &&from) noexcept {
if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
if (this != &from) InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
#endif
inline const ::std::string &unknown_fields() const {
return _internal_metadata_.unknown_fields();
}
inline ::std::string *mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields();
}
static const VarDesc &default_instance();
static inline const VarDesc *internal_default_instance() {
return reinterpret_cast<const VarDesc *>(&_VarDesc_default_instance_);
}
static PROTOBUF_CONSTEXPR int const kIndexInFileMessages = 13;
void Swap(VarDesc *other);
friend void swap(VarDesc &a, VarDesc &b) { a.Swap(&b); }
// implements Message
// ----------------------------------------------
inline VarDesc *New() const PROTOBUF_FINAL { return New(NULL); }
VarDesc *New(::google::protobuf::Arena *arena) const PROTOBUF_FINAL;
void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite &from)
PROTOBUF_FINAL;
void CopyFrom(const VarDesc &from);
void MergeFrom(const VarDesc &from);
void Clear() PROTOBUF_FINAL;
bool IsInitialized() const PROTOBUF_FINAL;
size_t ByteSizeLong() const PROTOBUF_FINAL;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream *input) PROTOBUF_FINAL;
void SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream *output) const PROTOBUF_FINAL;
void DiscardUnknownFields();
int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const;
void InternalSwap(VarDesc *other);
private:
inline ::google::protobuf::Arena *GetArenaNoVirtual() const { return NULL; }
inline void *MaybeArenaPtr() const { return NULL; }
public:
::std::string GetTypeName() const PROTOBUF_FINAL;
// nested types
// ----------------------------------------------------
// accessors
// -------------------------------------------------------
// required string name = 1;
bool has_name() const;
void clear_name();
static const int kNameFieldNumber = 1;
const ::std::string &name() const;
void set_name(const ::std::string &value);
#if LANG_CXX11
void set_name(::std::string &&value);
#endif
void set_name(const char *value);
void set_name(const char *value, size_t size);
::std::string *mutable_name();
::std::string *release_name();
void set_allocated_name(::std::string *name);
// required .paddle_mobile.framework.proto.VarType type = 2;
bool has_type() const;
void clear_type();
static const int kTypeFieldNumber = 2;
const ::paddle_mobile::framework::proto::VarType &type() const;
::paddle_mobile::framework::proto::VarType *mutable_type();
::paddle_mobile::framework::proto::VarType *release_type();
void set_allocated_type(::paddle_mobile::framework::proto::VarType *type);
// optional bool persistable = 3 [default = false];
bool has_persistable() const;
void clear_persistable();
static const int kPersistableFieldNumber = 3;
bool persistable() const;
void set_persistable(bool value);
// @@protoc_insertion_point(class_scope:paddle_mobile.framework.proto.VarDesc)
private:
void set_has_name();
void clear_has_name();
void set_has_type();
void clear_has_type();
void set_has_persistable();
void clear_has_persistable();
// helper for ByteSizeLong()
size_t RequiredFieldsByteSizeFallback() const;
::google::protobuf::internal::InternalMetadataWithArenaLite
_internal_metadata_;
::google::protobuf::internal::HasBits<1> _has_bits_;
mutable int _cached_size_;
::google::protobuf::internal::ArenaStringPtr name_;
::paddle_mobile::framework::proto::VarType *type_;
bool persistable_;
friend struct protobuf_framework_2eproto::TableStruct;
};
// -------------------------------------------------------------------
class BlockDesc
: public ::google::protobuf::
MessageLite /* @@protoc_insertion_point(class_definition:paddle_mobile.framework.proto.BlockDesc)
*/
{
public:
BlockDesc();
virtual ~BlockDesc();
BlockDesc(const BlockDesc &from);
inline BlockDesc &operator=(const BlockDesc &from) {
CopyFrom(from);
return *this;
}
#if LANG_CXX11
BlockDesc(BlockDesc &&from) noexcept : BlockDesc() {
*this = ::std::move(from);
}
inline BlockDesc &operator=(BlockDesc &&from) noexcept {
if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
if (this != &from) InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
#endif
inline const ::std::string &unknown_fields() const {
return _internal_metadata_.unknown_fields();
}
inline ::std::string *mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields();
}
static const BlockDesc &default_instance();
static inline const BlockDesc *internal_default_instance() {
return reinterpret_cast<const BlockDesc *>(&_BlockDesc_default_instance_);
}
static PROTOBUF_CONSTEXPR int const kIndexInFileMessages = 14;
void Swap(BlockDesc *other);
friend void swap(BlockDesc &a, BlockDesc &b) { a.Swap(&b); }
// implements Message
// ----------------------------------------------
inline BlockDesc *New() const PROTOBUF_FINAL { return New(NULL); }
BlockDesc *New(::google::protobuf::Arena *arena) const PROTOBUF_FINAL;
void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite &from)
PROTOBUF_FINAL;
void CopyFrom(const BlockDesc &from);
void MergeFrom(const BlockDesc &from);
void Clear() PROTOBUF_FINAL;
bool IsInitialized() const PROTOBUF_FINAL;
size_t ByteSizeLong() const PROTOBUF_FINAL;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream *input) PROTOBUF_FINAL;
void SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream *output) const PROTOBUF_FINAL;
void DiscardUnknownFields();
int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const;
void InternalSwap(BlockDesc *other);
private:
inline ::google::protobuf::Arena *GetArenaNoVirtual() const { return NULL; }
inline void *MaybeArenaPtr() const { return NULL; }
public:
::std::string GetTypeName() const PROTOBUF_FINAL;
// nested types
// ----------------------------------------------------
// accessors
// -------------------------------------------------------
// repeated .paddle_mobile.framework.proto.VarDesc vars = 3;
int vars_size() const;
void clear_vars();
static const int kVarsFieldNumber = 3;
const ::paddle_mobile::framework::proto::VarDesc &vars(int index) const;
::paddle_mobile::framework::proto::VarDesc *mutable_vars(int index);
::paddle_mobile::framework::proto::VarDesc *add_vars();
::google::protobuf::RepeatedPtrField<
::paddle_mobile::framework::proto::VarDesc>
*mutable_vars();
const ::google::protobuf::RepeatedPtrField<
::paddle_mobile::framework::proto::VarDesc>
&vars() const;
// repeated .paddle_mobile.framework.proto.OpDesc ops = 4;
int ops_size() const;
void clear_ops();
static const int kOpsFieldNumber = 4;
const ::paddle_mobile::framework::proto::OpDesc &ops(int index) const;
::paddle_mobile::framework::proto::OpDesc *mutable_ops(int index);
::paddle_mobile::framework::proto::OpDesc *add_ops();
::google::protobuf::RepeatedPtrField<
::paddle_mobile::framework::proto::OpDesc>
*mutable_ops();
const ::google::protobuf::RepeatedPtrField<
::paddle_mobile::framework::proto::OpDesc>
&ops() const;
// required int32 idx = 1;
bool has_idx() const;
void clear_idx();
static const int kIdxFieldNumber = 1;
::google::protobuf::int32 idx() const;
void set_idx(::google::protobuf::int32 value);
// required int32 parent_idx = 2;
bool has_parent_idx() const;
void clear_parent_idx();
static const int kParentIdxFieldNumber = 2;
::google::protobuf::int32 parent_idx() const;
void set_parent_idx(::google::protobuf::int32 value);
// optional int32 forward_block_idx = 5 [default = -1];
bool has_forward_block_idx() const;
void clear_forward_block_idx();
static const int kForwardBlockIdxFieldNumber = 5;
::google::protobuf::int32 forward_block_idx() const;
void set_forward_block_idx(::google::protobuf::int32 value);
// @@protoc_insertion_point(class_scope:paddle_mobile.framework.proto.BlockDesc)
private:
void set_has_idx();
void clear_has_idx();
void set_has_parent_idx();
void clear_has_parent_idx();
void set_has_forward_block_idx();
void clear_has_forward_block_idx();
// helper for ByteSizeLong()
size_t RequiredFieldsByteSizeFallback() const;
::google::protobuf::internal::InternalMetadataWithArenaLite
_internal_metadata_;
::google::protobuf::internal::HasBits<1> _has_bits_;
mutable int _cached_size_;
::google::protobuf::RepeatedPtrField<
::paddle_mobile::framework::proto::VarDesc>
vars_;
::google::protobuf::RepeatedPtrField<
::paddle_mobile::framework::proto::OpDesc>
ops_;
::google::protobuf::int32 idx_;
::google::protobuf::int32 parent_idx_;
::google::protobuf::int32 forward_block_idx_;
friend struct protobuf_framework_2eproto::TableStruct;
};
// -------------------------------------------------------------------
class ProgramDesc
: public ::google::protobuf::
MessageLite /* @@protoc_insertion_point(class_definition:paddle_mobile.framework.proto.ProgramDesc)
*/
{
public:
ProgramDesc();
virtual ~ProgramDesc();
ProgramDesc(const ProgramDesc &from);
inline ProgramDesc &operator=(const ProgramDesc &from) {
CopyFrom(from);
return *this;
}
#if LANG_CXX11
ProgramDesc(ProgramDesc &&from) noexcept : ProgramDesc() {
*this = ::std::move(from);
}
inline ProgramDesc &operator=(ProgramDesc &&from) noexcept {
if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
if (this != &from) InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
#endif
inline const ::std::string &unknown_fields() const {
return _internal_metadata_.unknown_fields();
}
inline ::std::string *mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields();
}
static const ProgramDesc &default_instance();
static inline const ProgramDesc *internal_default_instance() {
return reinterpret_cast<const ProgramDesc *>(
&_ProgramDesc_default_instance_);
}
static PROTOBUF_CONSTEXPR int const kIndexInFileMessages = 15;
void Swap(ProgramDesc *other);
friend void swap(ProgramDesc &a, ProgramDesc &b) { a.Swap(&b); }
// implements Message
// ----------------------------------------------
inline ProgramDesc *New() const PROTOBUF_FINAL { return New(NULL); }
ProgramDesc *New(::google::protobuf::Arena *arena) const PROTOBUF_FINAL;
void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite &from)
PROTOBUF_FINAL;
void CopyFrom(const ProgramDesc &from);
void MergeFrom(const ProgramDesc &from);
void Clear() PROTOBUF_FINAL;
bool IsInitialized() const PROTOBUF_FINAL;
size_t ByteSizeLong() const PROTOBUF_FINAL;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream *input) PROTOBUF_FINAL;
void SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream *output) const PROTOBUF_FINAL;
void DiscardUnknownFields();
int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const;
void InternalSwap(ProgramDesc *other);
private:
inline ::google::protobuf::Arena *GetArenaNoVirtual() const { return NULL; }
inline void *MaybeArenaPtr() const { return NULL; }
public:
::std::string GetTypeName() const PROTOBUF_FINAL;
// nested types
// ----------------------------------------------------
// accessors
// -------------------------------------------------------
// repeated .paddle_mobile.framework.proto.BlockDesc blocks = 1;
int blocks_size() const;
void clear_blocks();
static const int kBlocksFieldNumber = 1;
const ::paddle_mobile::framework::proto::BlockDesc &blocks(int index) const;
::paddle_mobile::framework::proto::BlockDesc *mutable_blocks(int index);
::paddle_mobile::framework::proto::BlockDesc *add_blocks();
::google::protobuf::RepeatedPtrField<
::paddle_mobile::framework::proto::BlockDesc>
*mutable_blocks();
const ::google::protobuf::RepeatedPtrField<
::paddle_mobile::framework::proto::BlockDesc>
&blocks() const;
// @@protoc_insertion_point(class_scope:paddle_mobile.framework.proto.ProgramDesc)
private:
::google::protobuf::internal::InternalMetadataWithArenaLite
_internal_metadata_;
::google::protobuf::internal::HasBits<1> _has_bits_;
mutable int _cached_size_;
::google::protobuf::RepeatedPtrField<
::paddle_mobile::framework::proto::BlockDesc>
blocks_;
friend struct protobuf_framework_2eproto::TableStruct;
};
// ===================================================================
// ===================================================================
#if !PROTOBUF_INLINE_NOT_IN_HEADERS
#ifdef __GNUC__
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wstrict-aliasing"
#endif // __GNUC__
// OpDesc_Attr
// required string name = 1;
inline bool OpDesc_Attr::has_name() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void OpDesc_Attr::set_has_name() { _has_bits_[0] |= 0x00000001u; }
inline void OpDesc_Attr::clear_has_name() { _has_bits_[0] &= ~0x00000001u; }
inline void OpDesc_Attr::clear_name() {
name_.ClearToEmptyNoArena(
&::google::protobuf::internal::GetEmptyStringAlreadyInited());
clear_has_name();
}
inline const ::std::string &OpDesc_Attr::name() const {
// @@protoc_insertion_point(field_get:paddle_mobile.framework.proto.OpDesc.Attr.name)
return name_.GetNoArena();
}
inline void OpDesc_Attr::set_name(const ::std::string &value) {
set_has_name();
name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
value);
// @@protoc_insertion_point(field_set:paddle_mobile.framework.proto.OpDesc.Attr.name)
}
#if LANG_CXX11
inline void OpDesc_Attr::set_name(::std::string &&value) {
set_has_name();
name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
::std::move(value));
// @@protoc_insertion_point(field_set_rvalue:paddle_mobile.framework.proto.OpDesc.Attr.name)
}
#endif
inline void OpDesc_Attr::set_name(const char *value) {
GOOGLE_DCHECK(value != NULL);
set_has_name();
name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
::std::string(value));
// @@protoc_insertion_point(field_set_char:paddle_mobile.framework.proto.OpDesc.Attr.name)
}
inline void OpDesc_Attr::set_name(const char *value, size_t size) {
set_has_name();
name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
::std::string(reinterpret_cast<const char *>(value), size));
// @@protoc_insertion_point(field_set_pointer:paddle_mobile.framework.proto.OpDesc.Attr.name)
}
inline ::std::string *OpDesc_Attr::mutable_name() {
set_has_name();
// @@protoc_insertion_point(field_mutable:paddle_mobile.framework.proto.OpDesc.Attr.name)
return name_.MutableNoArena(
&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string *OpDesc_Attr::release_name() {
// @@protoc_insertion_point(field_release:paddle_mobile.framework.proto.OpDesc.Attr.name)
clear_has_name();
return name_.ReleaseNoArena(
&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void OpDesc_Attr::set_allocated_name(::std::string *name) {
if (name != NULL) {
set_has_name();
} else {
clear_has_name();
}
name_.SetAllocatedNoArena(
&::google::protobuf::internal::GetEmptyStringAlreadyInited(), name);
// @@protoc_insertion_point(field_set_allocated:paddle_mobile.framework.proto.OpDesc.Attr.name)
}
// required .paddle_mobile.framework.proto.AttrType type = 2;
inline bool OpDesc_Attr::has_type() const {
return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void OpDesc_Attr::set_has_type() { _has_bits_[0] |= 0x00000004u; }
inline void OpDesc_Attr::clear_has_type() { _has_bits_[0] &= ~0x00000004u; }
inline void OpDesc_Attr::clear_type() {
type_ = 0;
clear_has_type();
}
inline ::paddle_mobile::framework::proto::AttrType OpDesc_Attr::type() const {
// @@protoc_insertion_point(field_get:paddle_mobile.framework.proto.OpDesc.Attr.type)
return static_cast<::paddle_mobile::framework::proto::AttrType>(type_);
}
inline void OpDesc_Attr::set_type(
::paddle_mobile::framework::proto::AttrType value) {
assert(::paddle_mobile::framework::proto::AttrType_IsValid(value));
set_has_type();
type_ = value;
// @@protoc_insertion_point(field_set:paddle_mobile.framework.proto.OpDesc.Attr.type)
}
// optional int32 i = 3;
inline bool OpDesc_Attr::has_i() const {
return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void OpDesc_Attr::set_has_i() { _has_bits_[0] |= 0x00000008u; }
inline void OpDesc_Attr::clear_has_i() { _has_bits_[0] &= ~0x00000008u; }
inline void OpDesc_Attr::clear_i() {
i_ = 0;
clear_has_i();
}
inline ::google::protobuf::int32 OpDesc_Attr::i() const {
// @@protoc_insertion_point(field_get:paddle_mobile.framework.proto.OpDesc.Attr.i)
return i_;
}
inline void OpDesc_Attr::set_i(::google::protobuf::int32 value) {
set_has_i();
i_ = value;
// @@protoc_insertion_point(field_set:paddle_mobile.framework.proto.OpDesc.Attr.i)
}
// optional float f = 4;
inline bool OpDesc_Attr::has_f() const {
return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void OpDesc_Attr::set_has_f() { _has_bits_[0] |= 0x00000010u; }
inline void OpDesc_Attr::clear_has_f() { _has_bits_[0] &= ~0x00000010u; }
inline void OpDesc_Attr::clear_f() {
f_ = 0;
clear_has_f();
}
inline float OpDesc_Attr::f() const {
// @@protoc_insertion_point(field_get:paddle_mobile.framework.proto.OpDesc.Attr.f)
return f_;
}
inline void OpDesc_Attr::set_f(float value) {
set_has_f();
f_ = value;
// @@protoc_insertion_point(field_set:paddle_mobile.framework.proto.OpDesc.Attr.f)
}
// optional string s = 5;
inline bool OpDesc_Attr::has_s() const {
return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void OpDesc_Attr::set_has_s() { _has_bits_[0] |= 0x00000002u; }
inline void OpDesc_Attr::clear_has_s() { _has_bits_[0] &= ~0x00000002u; }
inline void OpDesc_Attr::clear_s() {
s_.ClearToEmptyNoArena(
&::google::protobuf::internal::GetEmptyStringAlreadyInited());
clear_has_s();
}
inline const ::std::string &OpDesc_Attr::s() const {
// @@protoc_insertion_point(field_get:paddle_mobile.framework.proto.OpDesc.Attr.s)
return s_.GetNoArena();
}
inline void OpDesc_Attr::set_s(const ::std::string &value) {
set_has_s();
s_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
value);
// @@protoc_insertion_point(field_set:paddle_mobile.framework.proto.OpDesc.Attr.s)
}
#if LANG_CXX11
inline void OpDesc_Attr::set_s(::std::string &&value) {
set_has_s();
s_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
::std::move(value));
// @@protoc_insertion_point(field_set_rvalue:paddle_mobile.framework.proto.OpDesc.Attr.s)
}
#endif
inline void OpDesc_Attr::set_s(const char *value) {
GOOGLE_DCHECK(value != NULL);
set_has_s();
s_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
::std::string(value));
// @@protoc_insertion_point(field_set_char:paddle_mobile.framework.proto.OpDesc.Attr.s)
}
inline void OpDesc_Attr::set_s(const char *value, size_t size) {
set_has_s();
s_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
::std::string(reinterpret_cast<const char *>(value), size));
// @@protoc_insertion_point(field_set_pointer:paddle_mobile.framework.proto.OpDesc.Attr.s)
}
inline ::std::string *OpDesc_Attr::mutable_s() {
set_has_s();
// @@protoc_insertion_point(field_mutable:paddle_mobile.framework.proto.OpDesc.Attr.s)
return s_.MutableNoArena(
&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string *OpDesc_Attr::release_s() {
// @@protoc_insertion_point(field_release:paddle_mobile.framework.proto.OpDesc.Attr.s)
clear_has_s();
return s_.ReleaseNoArena(
&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void OpDesc_Attr::set_allocated_s(::std::string *s) {
if (s != NULL) {
set_has_s();
} else {
clear_has_s();
}
s_.SetAllocatedNoArena(
&::google::protobuf::internal::GetEmptyStringAlreadyInited(), s);
// @@protoc_insertion_point(field_set_allocated:paddle_mobile.framework.proto.OpDesc.Attr.s)
}
// repeated int32 ints = 6;
inline int OpDesc_Attr::ints_size() const { return ints_.size(); }
inline void OpDesc_Attr::clear_ints() { ints_.Clear(); }
inline ::google::protobuf::int32 OpDesc_Attr::ints(int index) const {
// @@protoc_insertion_point(field_get:paddle_mobile.framework.proto.OpDesc.Attr.ints)
return ints_.Get(index);
}
inline void OpDesc_Attr::set_ints(int index, ::google::protobuf::int32 value) {
ints_.Set(index, value);
// @@protoc_insertion_point(field_set:paddle_mobile.framework.proto.OpDesc.Attr.ints)
}
inline void OpDesc_Attr::add_ints(::google::protobuf::int32 value) {
ints_.Add(value);
// @@protoc_insertion_point(field_add:paddle_mobile.framework.proto.OpDesc.Attr.ints)
}
inline const ::google::protobuf::RepeatedField<::google::protobuf::int32>
&OpDesc_Attr::ints() const {
// @@protoc_insertion_point(field_list:paddle_mobile.framework.proto.OpDesc.Attr.ints)
return ints_;
}
inline ::google::protobuf::RepeatedField<::google::protobuf::int32>
*OpDesc_Attr::mutable_ints() {
// @@protoc_insertion_point(field_mutable_list:paddle_mobile.framework.proto.OpDesc.Attr.ints)
return &ints_;
}
// repeated float floats = 7;
inline int OpDesc_Attr::floats_size() const { return floats_.size(); }
inline void OpDesc_Attr::clear_floats() { floats_.Clear(); }
inline float OpDesc_Attr::floats(int index) const {
// @@protoc_insertion_point(field_get:paddle_mobile.framework.proto.OpDesc.Attr.floats)
return floats_.Get(index);
}
inline void OpDesc_Attr::set_floats(int index, float value) {
floats_.Set(index, value);
// @@protoc_insertion_point(field_set:paddle_mobile.framework.proto.OpDesc.Attr.floats)
}
inline void OpDesc_Attr::add_floats(float value) {
floats_.Add(value);
// @@protoc_insertion_point(field_add:paddle_mobile.framework.proto.OpDesc.Attr.floats)
}
inline const ::google::protobuf::RepeatedField<float> &OpDesc_Attr::floats()
const {
// @@protoc_insertion_point(field_list:paddle_mobile.framework.proto.OpDesc.Attr.floats)
return floats_;
}
inline ::google::protobuf::RepeatedField<float> *OpDesc_Attr::mutable_floats() {
// @@protoc_insertion_point(field_mutable_list:paddle_mobile.framework.proto.OpDesc.Attr.floats)
return &floats_;
}
// repeated string strings = 8;
inline int OpDesc_Attr::strings_size() const { return strings_.size(); }
inline void OpDesc_Attr::clear_strings() { strings_.Clear(); }
inline const ::std::string &OpDesc_Attr::strings(int index) const {
// @@protoc_insertion_point(field_get:paddle_mobile.framework.proto.OpDesc.Attr.strings)
return strings_.Get(index);
}
inline ::std::string *OpDesc_Attr::mutable_strings(int index) {
// @@protoc_insertion_point(field_mutable:paddle_mobile.framework.proto.OpDesc.Attr.strings)
return strings_.Mutable(index);
}
inline void OpDesc_Attr::set_strings(int index, const ::std::string &value) {
// @@protoc_insertion_point(field_set:paddle_mobile.framework.proto.OpDesc.Attr.strings)
strings_.Mutable(index)->assign(value);
}
#if LANG_CXX11
inline void OpDesc_Attr::set_strings(int index, ::std::string &&value) {
// @@protoc_insertion_point(field_set:paddle_mobile.framework.proto.OpDesc.Attr.strings)
strings_.Mutable(index)->assign(std::move(value));
}
#endif
inline void OpDesc_Attr::set_strings(int index, const char *value) {
GOOGLE_DCHECK(value != NULL);
strings_.Mutable(index)->assign(value);
// @@protoc_insertion_point(field_set_char:paddle_mobile.framework.proto.OpDesc.Attr.strings)
}
inline void OpDesc_Attr::set_strings(int index, const char *value,
size_t size) {
strings_.Mutable(index)->assign(reinterpret_cast<const char *>(value), size);
// @@protoc_insertion_point(field_set_pointer:paddle_mobile.framework.proto.OpDesc.Attr.strings)
}
inline ::std::string *OpDesc_Attr::add_strings() {
// @@protoc_insertion_point(field_add_mutable:paddle_mobile.framework.proto.OpDesc.Attr.strings)
return strings_.Add();
}
inline void OpDesc_Attr::add_strings(const ::std::string &value) {
strings_.Add()->assign(value);
// @@protoc_insertion_point(field_add:paddle_mobile.framework.proto.OpDesc.Attr.strings)
}
#if LANG_CXX11
inline void OpDesc_Attr::add_strings(::std::string &&value) {
strings_.Add(std::move(value));
// @@protoc_insertion_point(field_add:paddle_mobile.framework.proto.OpDesc.Attr.strings)
}
#endif
inline void OpDesc_Attr::add_strings(const char *value) {
GOOGLE_DCHECK(value != NULL);
strings_.Add()->assign(value);
// @@protoc_insertion_point(field_add_char:paddle_mobile.framework.proto.OpDesc.Attr.strings)
}
inline void OpDesc_Attr::add_strings(const char *value, size_t size) {
strings_.Add()->assign(reinterpret_cast<const char *>(value), size);
// @@protoc_insertion_point(field_add_pointer:paddle_mobile.framework.proto.OpDesc.Attr.strings)
}
inline const ::google::protobuf::RepeatedPtrField<::std::string>
&OpDesc_Attr::strings() const {
// @@protoc_insertion_point(field_list:paddle_mobile.framework.proto.OpDesc.Attr.strings)
return strings_;
}
inline ::google::protobuf::RepeatedPtrField<::std::string>
*OpDesc_Attr::mutable_strings() {
// @@protoc_insertion_point(field_mutable_list:paddle_mobile.framework.proto.OpDesc.Attr.strings)
return &strings_;
}
// optional bool b = 10;
inline bool OpDesc_Attr::has_b() const {
return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void OpDesc_Attr::set_has_b() { _has_bits_[0] |= 0x00000020u; }
inline void OpDesc_Attr::clear_has_b() { _has_bits_[0] &= ~0x00000020u; }
inline void OpDesc_Attr::clear_b() {
b_ = false;
clear_has_b();
}
inline bool OpDesc_Attr::b() const {
// @@protoc_insertion_point(field_get:paddle_mobile.framework.proto.OpDesc.Attr.b)
return b_;
}
inline void OpDesc_Attr::set_b(bool value) {
set_has_b();
b_ = value;
// @@protoc_insertion_point(field_set:paddle_mobile.framework.proto.OpDesc.Attr.b)
}
// repeated bool bools = 11;
inline int OpDesc_Attr::bools_size() const { return bools_.size(); }
inline void OpDesc_Attr::clear_bools() { bools_.Clear(); }
inline bool OpDesc_Attr::bools(int index) const {
// @@protoc_insertion_point(field_get:paddle_mobile.framework.proto.OpDesc.Attr.bools)
return bools_.Get(index);
}
inline void OpDesc_Attr::set_bools(int index, bool value) {
bools_.Set(index, value);
// @@protoc_insertion_point(field_set:paddle_mobile.framework.proto.OpDesc.Attr.bools)
}
inline void OpDesc_Attr::add_bools(bool value) {
bools_.Add(value);
// @@protoc_insertion_point(field_add:paddle_mobile.framework.proto.OpDesc.Attr.bools)
}
inline const ::google::protobuf::RepeatedField<bool> &OpDesc_Attr::bools()
const {
// @@protoc_insertion_point(field_list:paddle_mobile.framework.proto.OpDesc.Attr.bools)
return bools_;
}
inline ::google::protobuf::RepeatedField<bool> *OpDesc_Attr::mutable_bools() {
// @@protoc_insertion_point(field_mutable_list:paddle_mobile.framework.proto.OpDesc.Attr.bools)
return &bools_;
}
// optional int32 block_idx = 12;
inline bool OpDesc_Attr::has_block_idx() const {
return (_has_bits_[0] & 0x00000080u) != 0;
}
inline void OpDesc_Attr::set_has_block_idx() { _has_bits_[0] |= 0x00000080u; }
inline void OpDesc_Attr::clear_has_block_idx() {
_has_bits_[0] &= ~0x00000080u;
}
inline void OpDesc_Attr::clear_block_idx() {
block_idx_ = 0;
clear_has_block_idx();
}
inline ::google::protobuf::int32 OpDesc_Attr::block_idx() const {
// @@protoc_insertion_point(field_get:paddle_mobile.framework.proto.OpDesc.Attr.block_idx)
return block_idx_;
}
inline void OpDesc_Attr::set_block_idx(::google::protobuf::int32 value) {
set_has_block_idx();
block_idx_ = value;
// @@protoc_insertion_point(field_set:paddle_mobile.framework.proto.OpDesc.Attr.block_idx)
}
// optional int64 l = 13;
inline bool OpDesc_Attr::has_l() const {
return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void OpDesc_Attr::set_has_l() { _has_bits_[0] |= 0x00000040u; }
inline void OpDesc_Attr::clear_has_l() { _has_bits_[0] &= ~0x00000040u; }
inline void OpDesc_Attr::clear_l() {
l_ = GOOGLE_LONGLONG(0);
clear_has_l();
}
inline ::google::protobuf::int64 OpDesc_Attr::l() const {
// @@protoc_insertion_point(field_get:paddle_mobile.framework.proto.OpDesc.Attr.l)
return l_;
}
inline void OpDesc_Attr::set_l(::google::protobuf::int64 value) {
set_has_l();
l_ = value;
// @@protoc_insertion_point(field_set:paddle_mobile.framework.proto.OpDesc.Attr.l)
}
// -------------------------------------------------------------------
// OpDesc_Var
// required string parameter = 1;
inline bool OpDesc_Var::has_parameter() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void OpDesc_Var::set_has_parameter() { _has_bits_[0] |= 0x00000001u; }
inline void OpDesc_Var::clear_has_parameter() { _has_bits_[0] &= ~0x00000001u; }
inline void OpDesc_Var::clear_parameter() {
parameter_.ClearToEmptyNoArena(
&::google::protobuf::internal::GetEmptyStringAlreadyInited());
clear_has_parameter();
}
inline const ::std::string &OpDesc_Var::parameter() const {
// @@protoc_insertion_point(field_get:paddle_mobile.framework.proto.OpDesc.Var.parameter)
return parameter_.GetNoArena();
}
inline void OpDesc_Var::set_parameter(const ::std::string &value) {
set_has_parameter();
parameter_.SetNoArena(
&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
// @@protoc_insertion_point(field_set:paddle_mobile.framework.proto.OpDesc.Var.parameter)
}
#if LANG_CXX11
inline void OpDesc_Var::set_parameter(::std::string &&value) {
set_has_parameter();
parameter_.SetNoArena(
&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
::std::move(value));
// @@protoc_insertion_point(field_set_rvalue:paddle_mobile.framework.proto.OpDesc.Var.parameter)
}
#endif
inline void OpDesc_Var::set_parameter(const char *value) {
GOOGLE_DCHECK(value != NULL);
set_has_parameter();
parameter_.SetNoArena(
&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
::std::string(value));
// @@protoc_insertion_point(field_set_char:paddle_mobile.framework.proto.OpDesc.Var.parameter)
}
inline void OpDesc_Var::set_parameter(const char *value, size_t size) {
set_has_parameter();
parameter_.SetNoArena(
&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
::std::string(reinterpret_cast<const char *>(value), size));
// @@protoc_insertion_point(field_set_pointer:paddle_mobile.framework.proto.OpDesc.Var.parameter)
}
inline ::std::string *OpDesc_Var::mutable_parameter() {
set_has_parameter();
// @@protoc_insertion_point(field_mutable:paddle_mobile.framework.proto.OpDesc.Var.parameter)
return parameter_.MutableNoArena(
&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string *OpDesc_Var::release_parameter() {
// @@protoc_insertion_point(field_release:paddle_mobile.framework.proto.OpDesc.Var.parameter)
clear_has_parameter();
return parameter_.ReleaseNoArena(
&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void OpDesc_Var::set_allocated_parameter(::std::string *parameter) {
if (parameter != NULL) {
set_has_parameter();
} else {
clear_has_parameter();
}
parameter_.SetAllocatedNoArena(
&::google::protobuf::internal::GetEmptyStringAlreadyInited(), parameter);
// @@protoc_insertion_point(field_set_allocated:paddle_mobile.framework.proto.OpDesc.Var.parameter)
}
// repeated string arguments = 2;
inline int OpDesc_Var::arguments_size() const { return arguments_.size(); }
inline void OpDesc_Var::clear_arguments() { arguments_.Clear(); }
inline const ::std::string &OpDesc_Var::arguments(int index) const {
// @@protoc_insertion_point(field_get:paddle_mobile.framework.proto.OpDesc.Var.arguments)
return arguments_.Get(index);
}
inline ::std::string *OpDesc_Var::mutable_arguments(int index) {
// @@protoc_insertion_point(field_mutable:paddle_mobile.framework.proto.OpDesc.Var.arguments)
return arguments_.Mutable(index);
}
inline void OpDesc_Var::set_arguments(int index, const ::std::string &value) {
// @@protoc_insertion_point(field_set:paddle_mobile.framework.proto.OpDesc.Var.arguments)
arguments_.Mutable(index)->assign(value);
}
#if LANG_CXX11
inline void OpDesc_Var::set_arguments(int index, ::std::string &&value) {
// @@protoc_insertion_point(field_set:paddle_mobile.framework.proto.OpDesc.Var.arguments)
arguments_.Mutable(index)->assign(std::move(value));
}
#endif
inline void OpDesc_Var::set_arguments(int index, const char *value) {
GOOGLE_DCHECK(value != NULL);
arguments_.Mutable(index)->assign(value);
// @@protoc_insertion_point(field_set_char:paddle_mobile.framework.proto.OpDesc.Var.arguments)
}
inline void OpDesc_Var::set_arguments(int index, const char *value,
size_t size) {
arguments_.Mutable(index)->assign(reinterpret_cast<const char *>(value),
size);
// @@protoc_insertion_point(field_set_pointer:paddle_mobile.framework.proto.OpDesc.Var.arguments)
}
inline ::std::string *OpDesc_Var::add_arguments() {
// @@protoc_insertion_point(field_add_mutable:paddle_mobile.framework.proto.OpDesc.Var.arguments)
return arguments_.Add();
}
inline void OpDesc_Var::add_arguments(const ::std::string &value) {
arguments_.Add()->assign(value);
// @@protoc_insertion_point(field_add:paddle_mobile.framework.proto.OpDesc.Var.arguments)
}
#if LANG_CXX11
inline void OpDesc_Var::add_arguments(::std::string &&value) {
arguments_.Add(std::move(value));
// @@protoc_insertion_point(field_add:paddle_mobile.framework.proto.OpDesc.Var.arguments)
}
#endif
inline void OpDesc_Var::add_arguments(const char *value) {
GOOGLE_DCHECK(value != NULL);
arguments_.Add()->assign(value);
// @@protoc_insertion_point(field_add_char:paddle_mobile.framework.proto.OpDesc.Var.arguments)
}
inline void OpDesc_Var::add_arguments(const char *value, size_t size) {
arguments_.Add()->assign(reinterpret_cast<const char *>(value), size);
// @@protoc_insertion_point(field_add_pointer:paddle_mobile.framework.proto.OpDesc.Var.arguments)
}
inline const ::google::protobuf::RepeatedPtrField<::std::string>
&OpDesc_Var::arguments() const {
// @@protoc_insertion_point(field_list:paddle_mobile.framework.proto.OpDesc.Var.arguments)
return arguments_;
}
inline ::google::protobuf::RepeatedPtrField<::std::string>
*OpDesc_Var::mutable_arguments() {
// @@protoc_insertion_point(field_mutable_list:paddle_mobile.framework.proto.OpDesc.Var.arguments)
return &arguments_;
}
// -------------------------------------------------------------------
// OpDesc
// required string type = 3;
inline bool OpDesc::has_type() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void OpDesc::set_has_type() { _has_bits_[0] |= 0x00000001u; }
inline void OpDesc::clear_has_type() { _has_bits_[0] &= ~0x00000001u; }
inline void OpDesc::clear_type() {
type_.ClearToEmptyNoArena(
&::google::protobuf::internal::GetEmptyStringAlreadyInited());
clear_has_type();
}
inline const ::std::string &OpDesc::type() const {
// @@protoc_insertion_point(field_get:paddle_mobile.framework.proto.OpDesc.type)
return type_.GetNoArena();
}
inline void OpDesc::set_type(const ::std::string &value) {
set_has_type();
type_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
value);
// @@protoc_insertion_point(field_set:paddle_mobile.framework.proto.OpDesc.type)
}
#if LANG_CXX11
inline void OpDesc::set_type(::std::string &&value) {
set_has_type();
type_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
::std::move(value));
// @@protoc_insertion_point(field_set_rvalue:paddle_mobile.framework.proto.OpDesc.type)
}
#endif
inline void OpDesc::set_type(const char *value) {
GOOGLE_DCHECK(value != NULL);
set_has_type();
type_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
::std::string(value));
// @@protoc_insertion_point(field_set_char:paddle_mobile.framework.proto.OpDesc.type)
}
inline void OpDesc::set_type(const char *value, size_t size) {
set_has_type();
type_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
::std::string(reinterpret_cast<const char *>(value), size));
// @@protoc_insertion_point(field_set_pointer:paddle_mobile.framework.proto.OpDesc.type)
}
inline ::std::string *OpDesc::mutable_type() {
set_has_type();
// @@protoc_insertion_point(field_mutable:paddle_mobile.framework.proto.OpDesc.type)
return type_.MutableNoArena(
&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string *OpDesc::release_type() {
// @@protoc_insertion_point(field_release:paddle_mobile.framework.proto.OpDesc.type)
clear_has_type();
return type_.ReleaseNoArena(
&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void OpDesc::set_allocated_type(::std::string *type) {
if (type != NULL) {
set_has_type();
} else {
clear_has_type();
}
type_.SetAllocatedNoArena(
&::google::protobuf::internal::GetEmptyStringAlreadyInited(), type);
// @@protoc_insertion_point(field_set_allocated:paddle_mobile.framework.proto.OpDesc.type)
}
// repeated .paddle_mobile.framework.proto.OpDesc.Var inputs = 1;
inline int OpDesc::inputs_size() const { return inputs_.size(); }
inline void OpDesc::clear_inputs() { inputs_.Clear(); }
inline const ::paddle_mobile::framework::proto::OpDesc_Var &OpDesc::inputs(
int index) const {
// @@protoc_insertion_point(field_get:paddle_mobile.framework.proto.OpDesc.inputs)
return inputs_.Get(index);
}
inline ::paddle_mobile::framework::proto::OpDesc_Var *OpDesc::mutable_inputs(
int index) {
// @@protoc_insertion_point(field_mutable:paddle_mobile.framework.proto.OpDesc.inputs)
return inputs_.Mutable(index);
}
inline ::paddle_mobile::framework::proto::OpDesc_Var *OpDesc::add_inputs() {
// @@protoc_insertion_point(field_add:paddle_mobile.framework.proto.OpDesc.inputs)
return inputs_.Add();
}
inline ::google::protobuf::RepeatedPtrField<
::paddle_mobile::framework::proto::OpDesc_Var>
*OpDesc::mutable_inputs() {
// @@protoc_insertion_point(field_mutable_list:paddle_mobile.framework.proto.OpDesc.inputs)
return &inputs_;
}
inline const ::google::protobuf::RepeatedPtrField<
::paddle_mobile::framework::proto::OpDesc_Var>
&OpDesc::inputs() const {
// @@protoc_insertion_point(field_list:paddle_mobile.framework.proto.OpDesc.inputs)
return inputs_;
}
// repeated .paddle_mobile.framework.proto.OpDesc.Var outputs = 2;
inline int OpDesc::outputs_size() const { return outputs_.size(); }
inline void OpDesc::clear_outputs() { outputs_.Clear(); }
inline const ::paddle_mobile::framework::proto::OpDesc_Var &OpDesc::outputs(
int index) const {
// @@protoc_insertion_point(field_get:paddle_mobile.framework.proto.OpDesc.outputs)
return outputs_.Get(index);
}
inline ::paddle_mobile::framework::proto::OpDesc_Var *OpDesc::mutable_outputs(
int index) {
// @@protoc_insertion_point(field_mutable:paddle_mobile.framework.proto.OpDesc.outputs)
return outputs_.Mutable(index);
}
inline ::paddle_mobile::framework::proto::OpDesc_Var *OpDesc::add_outputs() {
// @@protoc_insertion_point(field_add:paddle_mobile.framework.proto.OpDesc.outputs)
return outputs_.Add();
}
inline ::google::protobuf::RepeatedPtrField<
::paddle_mobile::framework::proto::OpDesc_Var>
*OpDesc::mutable_outputs() {
// @@protoc_insertion_point(field_mutable_list:paddle_mobile.framework.proto.OpDesc.outputs)
return &outputs_;
}
inline const ::google::protobuf::RepeatedPtrField<
::paddle_mobile::framework::proto::OpDesc_Var>
&OpDesc::outputs() const {
// @@protoc_insertion_point(field_list:paddle_mobile.framework.proto.OpDesc.outputs)
return outputs_;
}
// repeated .paddle_mobile.framework.proto.OpDesc.Attr attrs = 4;
inline int OpDesc::attrs_size() const { return attrs_.size(); }
inline void OpDesc::clear_attrs() { attrs_.Clear(); }
inline const ::paddle_mobile::framework::proto::OpDesc_Attr &OpDesc::attrs(
int index) const {
// @@protoc_insertion_point(field_get:paddle_mobile.framework.proto.OpDesc.attrs)
return attrs_.Get(index);
}
inline ::paddle_mobile::framework::proto::OpDesc_Attr *OpDesc::mutable_attrs(
int index) {
// @@protoc_insertion_point(field_mutable:paddle_mobile.framework.proto.OpDesc.attrs)
return attrs_.Mutable(index);
}
inline ::paddle_mobile::framework::proto::OpDesc_Attr *OpDesc::add_attrs() {
// @@protoc_insertion_point(field_add:paddle_mobile.framework.proto.OpDesc.attrs)
return attrs_.Add();
}
inline ::google::protobuf::RepeatedPtrField<
::paddle_mobile::framework::proto::OpDesc_Attr>
*OpDesc::mutable_attrs() {
// @@protoc_insertion_point(field_mutable_list:paddle_mobile.framework.proto.OpDesc.attrs)
return &attrs_;
}
inline const ::google::protobuf::RepeatedPtrField<
::paddle_mobile::framework::proto::OpDesc_Attr>
&OpDesc::attrs() const {
// @@protoc_insertion_point(field_list:paddle_mobile.framework.proto.OpDesc.attrs)
return attrs_;
}
// optional bool is_target = 5 [default = false];
inline bool OpDesc::has_is_target() const {
return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void OpDesc::set_has_is_target() { _has_bits_[0] |= 0x00000002u; }
inline void OpDesc::clear_has_is_target() { _has_bits_[0] &= ~0x00000002u; }
inline void OpDesc::clear_is_target() {
is_target_ = false;
clear_has_is_target();
}
inline bool OpDesc::is_target() const {
// @@protoc_insertion_point(field_get:paddle_mobile.framework.proto.OpDesc.is_target)
return is_target_;
}
inline void OpDesc::set_is_target(bool value) {
set_has_is_target();
is_target_ = value;
// @@protoc_insertion_point(field_set:paddle_mobile.framework.proto.OpDesc.is_target)
}
// -------------------------------------------------------------------
// OpProto_Var
// required string name = 1;
inline bool OpProto_Var::has_name() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void OpProto_Var::set_has_name() { _has_bits_[0] |= 0x00000001u; }
inline void OpProto_Var::clear_has_name() { _has_bits_[0] &= ~0x00000001u; }
inline void OpProto_Var::clear_name() {
name_.ClearToEmptyNoArena(
&::google::protobuf::internal::GetEmptyStringAlreadyInited());
clear_has_name();
}
inline const ::std::string &OpProto_Var::name() const {
// @@protoc_insertion_point(field_get:paddle_mobile.framework.proto.OpProto.Var.name)
return name_.GetNoArena();
}
inline void OpProto_Var::set_name(const ::std::string &value) {
set_has_name();
name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
value);
// @@protoc_insertion_point(field_set:paddle_mobile.framework.proto.OpProto.Var.name)
}
#if LANG_CXX11
inline void OpProto_Var::set_name(::std::string &&value) {
set_has_name();
name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
::std::move(value));
// @@protoc_insertion_point(field_set_rvalue:paddle_mobile.framework.proto.OpProto.Var.name)
}
#endif
inline void OpProto_Var::set_name(const char *value) {
GOOGLE_DCHECK(value != NULL);
set_has_name();
name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
::std::string(value));
// @@protoc_insertion_point(field_set_char:paddle_mobile.framework.proto.OpProto.Var.name)
}
inline void OpProto_Var::set_name(const char *value, size_t size) {
set_has_name();
name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
::std::string(reinterpret_cast<const char *>(value), size));
// @@protoc_insertion_point(field_set_pointer:paddle_mobile.framework.proto.OpProto.Var.name)
}
inline ::std::string *OpProto_Var::mutable_name() {
set_has_name();
// @@protoc_insertion_point(field_mutable:paddle_mobile.framework.proto.OpProto.Var.name)
return name_.MutableNoArena(
&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string *OpProto_Var::release_name() {
// @@protoc_insertion_point(field_release:paddle_mobile.framework.proto.OpProto.Var.name)
clear_has_name();
return name_.ReleaseNoArena(
&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void OpProto_Var::set_allocated_name(::std::string *name) {
if (name != NULL) {
set_has_name();
} else {
clear_has_name();
}
name_.SetAllocatedNoArena(
&::google::protobuf::internal::GetEmptyStringAlreadyInited(), name);
// @@protoc_insertion_point(field_set_allocated:paddle_mobile.framework.proto.OpProto.Var.name)
}
// required string comment = 2;
inline bool OpProto_Var::has_comment() const {
return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void OpProto_Var::set_has_comment() { _has_bits_[0] |= 0x00000002u; }
inline void OpProto_Var::clear_has_comment() { _has_bits_[0] &= ~0x00000002u; }
inline void OpProto_Var::clear_comment() {
comment_.ClearToEmptyNoArena(
&::google::protobuf::internal::GetEmptyStringAlreadyInited());
clear_has_comment();
}
inline const ::std::string &OpProto_Var::comment() const {
// @@protoc_insertion_point(field_get:paddle_mobile.framework.proto.OpProto.Var.comment)
return comment_.GetNoArena();
}
inline void OpProto_Var::set_comment(const ::std::string &value) {
set_has_comment();
comment_.SetNoArena(
&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
// @@protoc_insertion_point(field_set:paddle_mobile.framework.proto.OpProto.Var.comment)
}
#if LANG_CXX11
inline void OpProto_Var::set_comment(::std::string &&value) {
set_has_comment();
comment_.SetNoArena(
&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
::std::move(value));
// @@protoc_insertion_point(field_set_rvalue:paddle_mobile.framework.proto.OpProto.Var.comment)
}
#endif
inline void OpProto_Var::set_comment(const char *value) {
GOOGLE_DCHECK(value != NULL);
set_has_comment();
comment_.SetNoArena(
&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
::std::string(value));
// @@protoc_insertion_point(field_set_char:paddle_mobile.framework.proto.OpProto.Var.comment)
}
inline void OpProto_Var::set_comment(const char *value, size_t size) {
set_has_comment();
comment_.SetNoArena(
&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
::std::string(reinterpret_cast<const char *>(value), size));
// @@protoc_insertion_point(field_set_pointer:paddle_mobile.framework.proto.OpProto.Var.comment)
}
inline ::std::string *OpProto_Var::mutable_comment() {
set_has_comment();
// @@protoc_insertion_point(field_mutable:paddle_mobile.framework.proto.OpProto.Var.comment)
return comment_.MutableNoArena(
&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string *OpProto_Var::release_comment() {
// @@protoc_insertion_point(field_release:paddle_mobile.framework.proto.OpProto.Var.comment)
clear_has_comment();
return comment_.ReleaseNoArena(
&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void OpProto_Var::set_allocated_comment(::std::string *comment) {
if (comment != NULL) {
set_has_comment();
} else {
clear_has_comment();
}
comment_.SetAllocatedNoArena(
&::google::protobuf::internal::GetEmptyStringAlreadyInited(), comment);
// @@protoc_insertion_point(field_set_allocated:paddle_mobile.framework.proto.OpProto.Var.comment)
}
// optional bool duplicable = 3 [default = false];
inline bool OpProto_Var::has_duplicable() const {
return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void OpProto_Var::set_has_duplicable() { _has_bits_[0] |= 0x00000004u; }
inline void OpProto_Var::clear_has_duplicable() {
_has_bits_[0] &= ~0x00000004u;
}
inline void OpProto_Var::clear_duplicable() {
duplicable_ = false;
clear_has_duplicable();
}
inline bool OpProto_Var::duplicable() const {
// @@protoc_insertion_point(field_get:paddle_mobile.framework.proto.OpProto.Var.duplicable)
return duplicable_;
}
inline void OpProto_Var::set_duplicable(bool value) {
set_has_duplicable();
duplicable_ = value;
// @@protoc_insertion_point(field_set:paddle_mobile.framework.proto.OpProto.Var.duplicable)
}
// optional bool intermediate = 4 [default = false];
inline bool OpProto_Var::has_intermediate() const {
return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void OpProto_Var::set_has_intermediate() {
_has_bits_[0] |= 0x00000008u;
}
inline void OpProto_Var::clear_has_intermediate() {
_has_bits_[0] &= ~0x00000008u;
}
inline void OpProto_Var::clear_intermediate() {
intermediate_ = false;
clear_has_intermediate();
}
inline bool OpProto_Var::intermediate() const {
// @@protoc_insertion_point(field_get:paddle_mobile.framework.proto.OpProto.Var.intermediate)
return intermediate_;
}
inline void OpProto_Var::set_intermediate(bool value) {
set_has_intermediate();
intermediate_ = value;
// @@protoc_insertion_point(field_set:paddle_mobile.framework.proto.OpProto.Var.intermediate)
}
// optional bool dispensable = 5 [default = false];
inline bool OpProto_Var::has_dispensable() const {
return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void OpProto_Var::set_has_dispensable() { _has_bits_[0] |= 0x00000010u; }
inline void OpProto_Var::clear_has_dispensable() {
_has_bits_[0] &= ~0x00000010u;
}
inline void OpProto_Var::clear_dispensable() {
dispensable_ = false;
clear_has_dispensable();
}
inline bool OpProto_Var::dispensable() const {
// @@protoc_insertion_point(field_get:paddle_mobile.framework.proto.OpProto.Var.dispensable)
return dispensable_;
}
inline void OpProto_Var::set_dispensable(bool value) {
set_has_dispensable();
dispensable_ = value;
// @@protoc_insertion_point(field_set:paddle_mobile.framework.proto.OpProto.Var.dispensable)
}
// -------------------------------------------------------------------
// OpProto_Attr
// required string name = 1;
inline bool OpProto_Attr::has_name() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void OpProto_Attr::set_has_name() { _has_bits_[0] |= 0x00000001u; }
inline void OpProto_Attr::clear_has_name() { _has_bits_[0] &= ~0x00000001u; }
inline void OpProto_Attr::clear_name() {
name_.ClearToEmptyNoArena(
&::google::protobuf::internal::GetEmptyStringAlreadyInited());
clear_has_name();
}
inline const ::std::string &OpProto_Attr::name() const {
// @@protoc_insertion_point(field_get:paddle_mobile.framework.proto.OpProto.Attr.name)
return name_.GetNoArena();
}
inline void OpProto_Attr::set_name(const ::std::string &value) {
set_has_name();
name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
value);
// @@protoc_insertion_point(field_set:paddle_mobile.framework.proto.OpProto.Attr.name)
}
#if LANG_CXX11
inline void OpProto_Attr::set_name(::std::string &&value) {
set_has_name();
name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
::std::move(value));
// @@protoc_insertion_point(field_set_rvalue:paddle_mobile.framework.proto.OpProto.Attr.name)
}
#endif
inline void OpProto_Attr::set_name(const char *value) {
GOOGLE_DCHECK(value != NULL);
set_has_name();
name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
::std::string(value));
// @@protoc_insertion_point(field_set_char:paddle_mobile.framework.proto.OpProto.Attr.name)
}
inline void OpProto_Attr::set_name(const char *value, size_t size) {
set_has_name();
name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
::std::string(reinterpret_cast<const char *>(value), size));
// @@protoc_insertion_point(field_set_pointer:paddle_mobile.framework.proto.OpProto.Attr.name)
}
inline ::std::string *OpProto_Attr::mutable_name() {
set_has_name();
// @@protoc_insertion_point(field_mutable:paddle_mobile.framework.proto.OpProto.Attr.name)
return name_.MutableNoArena(
&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string *OpProto_Attr::release_name() {
// @@protoc_insertion_point(field_release:paddle_mobile.framework.proto.OpProto.Attr.name)
clear_has_name();
return name_.ReleaseNoArena(
&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void OpProto_Attr::set_allocated_name(::std::string *name) {
if (name != NULL) {
set_has_name();
} else {
clear_has_name();
}
name_.SetAllocatedNoArena(
&::google::protobuf::internal::GetEmptyStringAlreadyInited(), name);
// @@protoc_insertion_point(field_set_allocated:paddle_mobile.framework.proto.OpProto.Attr.name)
}
// required .paddle_mobile.framework.proto.AttrType type = 2;
inline bool OpProto_Attr::has_type() const {
return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void OpProto_Attr::set_has_type() { _has_bits_[0] |= 0x00000004u; }
inline void OpProto_Attr::clear_has_type() { _has_bits_[0] &= ~0x00000004u; }
inline void OpProto_Attr::clear_type() {
type_ = 0;
clear_has_type();
}
inline ::paddle_mobile::framework::proto::AttrType OpProto_Attr::type() const {
// @@protoc_insertion_point(field_get:paddle_mobile.framework.proto.OpProto.Attr.type)
return static_cast<::paddle_mobile::framework::proto::AttrType>(type_);
}
inline void OpProto_Attr::set_type(
::paddle_mobile::framework::proto::AttrType value) {
assert(::paddle_mobile::framework::proto::AttrType_IsValid(value));
set_has_type();
type_ = value;
// @@protoc_insertion_point(field_set:paddle_mobile.framework.proto.OpProto.Attr.type)
}
// required string comment = 3;
inline bool OpProto_Attr::has_comment() const {
return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void OpProto_Attr::set_has_comment() { _has_bits_[0] |= 0x00000002u; }
inline void OpProto_Attr::clear_has_comment() { _has_bits_[0] &= ~0x00000002u; }
inline void OpProto_Attr::clear_comment() {
comment_.ClearToEmptyNoArena(
&::google::protobuf::internal::GetEmptyStringAlreadyInited());
clear_has_comment();
}
inline const ::std::string &OpProto_Attr::comment() const {
// @@protoc_insertion_point(field_get:paddle_mobile.framework.proto.OpProto.Attr.comment)
return comment_.GetNoArena();
}
inline void OpProto_Attr::set_comment(const ::std::string &value) {
set_has_comment();
comment_.SetNoArena(
&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
// @@protoc_insertion_point(field_set:paddle_mobile.framework.proto.OpProto.Attr.comment)
}
#if LANG_CXX11
inline void OpProto_Attr::set_comment(::std::string &&value) {
set_has_comment();
comment_.SetNoArena(
&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
::std::move(value));
// @@protoc_insertion_point(field_set_rvalue:paddle_mobile.framework.proto.OpProto.Attr.comment)
}
#endif
inline void OpProto_Attr::set_comment(const char *value) {
GOOGLE_DCHECK(value != NULL);
set_has_comment();
comment_.SetNoArena(
&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
::std::string(value));
// @@protoc_insertion_point(field_set_char:paddle_mobile.framework.proto.OpProto.Attr.comment)
}
inline void OpProto_Attr::set_comment(const char *value, size_t size) {
set_has_comment();
comment_.SetNoArena(
&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
::std::string(reinterpret_cast<const char *>(value), size));
// @@protoc_insertion_point(field_set_pointer:paddle_mobile.framework.proto.OpProto.Attr.comment)
}
inline ::std::string *OpProto_Attr::mutable_comment() {
set_has_comment();
// @@protoc_insertion_point(field_mutable:paddle_mobile.framework.proto.OpProto.Attr.comment)
return comment_.MutableNoArena(
&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string *OpProto_Attr::release_comment() {
// @@protoc_insertion_point(field_release:paddle_mobile.framework.proto.OpProto.Attr.comment)
clear_has_comment();
return comment_.ReleaseNoArena(
&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void OpProto_Attr::set_allocated_comment(::std::string *comment) {
if (comment != NULL) {
set_has_comment();
} else {
clear_has_comment();
}
comment_.SetAllocatedNoArena(
&::google::protobuf::internal::GetEmptyStringAlreadyInited(), comment);
// @@protoc_insertion_point(field_set_allocated:paddle_mobile.framework.proto.OpProto.Attr.comment)
}
// optional bool generated = 4 [default = false];
inline bool OpProto_Attr::has_generated() const {
return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void OpProto_Attr::set_has_generated() { _has_bits_[0] |= 0x00000008u; }
inline void OpProto_Attr::clear_has_generated() {
_has_bits_[0] &= ~0x00000008u;
}
inline void OpProto_Attr::clear_generated() {
generated_ = false;
clear_has_generated();
}
inline bool OpProto_Attr::generated() const {
// @@protoc_insertion_point(field_get:paddle_mobile.framework.proto.OpProto.Attr.generated)
return generated_;
}
inline void OpProto_Attr::set_generated(bool value) {
set_has_generated();
generated_ = value;
// @@protoc_insertion_point(field_set:paddle_mobile.framework.proto.OpProto.Attr.generated)
}
// -------------------------------------------------------------------
// OpProto
// required string type = 1;
inline bool OpProto::has_type() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void OpProto::set_has_type() { _has_bits_[0] |= 0x00000001u; }
inline void OpProto::clear_has_type() { _has_bits_[0] &= ~0x00000001u; }
inline void OpProto::clear_type() {
type_.ClearToEmptyNoArena(
&::google::protobuf::internal::GetEmptyStringAlreadyInited());
clear_has_type();
}
inline const ::std::string &OpProto::type() const {
// @@protoc_insertion_point(field_get:paddle_mobile.framework.proto.OpProto.type)
return type_.GetNoArena();
}
inline void OpProto::set_type(const ::std::string &value) {
set_has_type();
type_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
value);
// @@protoc_insertion_point(field_set:paddle_mobile.framework.proto.OpProto.type)
}
#if LANG_CXX11
inline void OpProto::set_type(::std::string &&value) {
set_has_type();
type_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
::std::move(value));
// @@protoc_insertion_point(field_set_rvalue:paddle_mobile.framework.proto.OpProto.type)
}
#endif
inline void OpProto::set_type(const char *value) {
GOOGLE_DCHECK(value != NULL);
set_has_type();
type_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
::std::string(value));
// @@protoc_insertion_point(field_set_char:paddle_mobile.framework.proto.OpProto.type)
}
inline void OpProto::set_type(const char *value, size_t size) {
set_has_type();
type_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
::std::string(reinterpret_cast<const char *>(value), size));
// @@protoc_insertion_point(field_set_pointer:paddle_mobile.framework.proto.OpProto.type)
}
inline ::std::string *OpProto::mutable_type() {
set_has_type();
// @@protoc_insertion_point(field_mutable:paddle_mobile.framework.proto.OpProto.type)
return type_.MutableNoArena(
&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string *OpProto::release_type() {
// @@protoc_insertion_point(field_release:paddle_mobile.framework.proto.OpProto.type)
clear_has_type();
return type_.ReleaseNoArena(
&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void OpProto::set_allocated_type(::std::string *type) {
if (type != NULL) {
set_has_type();
} else {
clear_has_type();
}
type_.SetAllocatedNoArena(
&::google::protobuf::internal::GetEmptyStringAlreadyInited(), type);
// @@protoc_insertion_point(field_set_allocated:paddle_mobile.framework.proto.OpProto.type)
}
// repeated .paddle_mobile.framework.proto.OpProto.Var inputs = 2;
inline int OpProto::inputs_size() const { return inputs_.size(); }
inline void OpProto::clear_inputs() { inputs_.Clear(); }
inline const ::paddle_mobile::framework::proto::OpProto_Var &OpProto::inputs(
int index) const {
// @@protoc_insertion_point(field_get:paddle_mobile.framework.proto.OpProto.inputs)
return inputs_.Get(index);
}
inline ::paddle_mobile::framework::proto::OpProto_Var *OpProto::mutable_inputs(
int index) {
// @@protoc_insertion_point(field_mutable:paddle_mobile.framework.proto.OpProto.inputs)
return inputs_.Mutable(index);
}
inline ::paddle_mobile::framework::proto::OpProto_Var *OpProto::add_inputs() {
// @@protoc_insertion_point(field_add:paddle_mobile.framework.proto.OpProto.inputs)
return inputs_.Add();
}
inline ::google::protobuf::RepeatedPtrField<
::paddle_mobile::framework::proto::OpProto_Var>
*OpProto::mutable_inputs() {
// @@protoc_insertion_point(field_mutable_list:paddle_mobile.framework.proto.OpProto.inputs)
return &inputs_;
}
inline const ::google::protobuf::RepeatedPtrField<
::paddle_mobile::framework::proto::OpProto_Var>
&OpProto::inputs() const {
// @@protoc_insertion_point(field_list:paddle_mobile.framework.proto.OpProto.inputs)
return inputs_;
}
// repeated .paddle_mobile.framework.proto.OpProto.Var outputs = 3;
inline int OpProto::outputs_size() const { return outputs_.size(); }
inline void OpProto::clear_outputs() { outputs_.Clear(); }
inline const ::paddle_mobile::framework::proto::OpProto_Var &OpProto::outputs(
int index) const {
// @@protoc_insertion_point(field_get:paddle_mobile.framework.proto.OpProto.outputs)
return outputs_.Get(index);
}
inline ::paddle_mobile::framework::proto::OpProto_Var *OpProto::mutable_outputs(
int index) {
// @@protoc_insertion_point(field_mutable:paddle_mobile.framework.proto.OpProto.outputs)
return outputs_.Mutable(index);
}
inline ::paddle_mobile::framework::proto::OpProto_Var *OpProto::add_outputs() {
// @@protoc_insertion_point(field_add:paddle_mobile.framework.proto.OpProto.outputs)
return outputs_.Add();
}
inline ::google::protobuf::RepeatedPtrField<
::paddle_mobile::framework::proto::OpProto_Var>
*OpProto::mutable_outputs() {
// @@protoc_insertion_point(field_mutable_list:paddle_mobile.framework.proto.OpProto.outputs)
return &outputs_;
}
inline const ::google::protobuf::RepeatedPtrField<
::paddle_mobile::framework::proto::OpProto_Var>
&OpProto::outputs() const {
// @@protoc_insertion_point(field_list:paddle_mobile.framework.proto.OpProto.outputs)
return outputs_;
}
// repeated .paddle_mobile.framework.proto.OpProto.Attr attrs = 4;
inline int OpProto::attrs_size() const { return attrs_.size(); }
inline void OpProto::clear_attrs() { attrs_.Clear(); }
inline const ::paddle_mobile::framework::proto::OpProto_Attr &OpProto::attrs(
int index) const {
// @@protoc_insertion_point(field_get:paddle_mobile.framework.proto.OpProto.attrs)
return attrs_.Get(index);
}
inline ::paddle_mobile::framework::proto::OpProto_Attr *OpProto::mutable_attrs(
int index) {
// @@protoc_insertion_point(field_mutable:paddle_mobile.framework.proto.OpProto.attrs)
return attrs_.Mutable(index);
}
inline ::paddle_mobile::framework::proto::OpProto_Attr *OpProto::add_attrs() {
// @@protoc_insertion_point(field_add:paddle_mobile.framework.proto.OpProto.attrs)
return attrs_.Add();
}
inline ::google::protobuf::RepeatedPtrField<
::paddle_mobile::framework::proto::OpProto_Attr>
*OpProto::mutable_attrs() {
// @@protoc_insertion_point(field_mutable_list:paddle_mobile.framework.proto.OpProto.attrs)
return &attrs_;
}
inline const ::google::protobuf::RepeatedPtrField<
::paddle_mobile::framework::proto::OpProto_Attr>
&OpProto::attrs() const {
// @@protoc_insertion_point(field_list:paddle_mobile.framework.proto.OpProto.attrs)
return attrs_;
}
// required string comment = 5;
inline bool OpProto::has_comment() const {
return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void OpProto::set_has_comment() { _has_bits_[0] |= 0x00000002u; }
inline void OpProto::clear_has_comment() { _has_bits_[0] &= ~0x00000002u; }
inline void OpProto::clear_comment() {
comment_.ClearToEmptyNoArena(
&::google::protobuf::internal::GetEmptyStringAlreadyInited());
clear_has_comment();
}
inline const ::std::string &OpProto::comment() const {
// @@protoc_insertion_point(field_get:paddle_mobile.framework.proto.OpProto.comment)
return comment_.GetNoArena();
}
inline void OpProto::set_comment(const ::std::string &value) {
set_has_comment();
comment_.SetNoArena(
&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
// @@protoc_insertion_point(field_set:paddle_mobile.framework.proto.OpProto.comment)
}
#if LANG_CXX11
inline void OpProto::set_comment(::std::string &&value) {
set_has_comment();
comment_.SetNoArena(
&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
::std::move(value));
// @@protoc_insertion_point(field_set_rvalue:paddle_mobile.framework.proto.OpProto.comment)
}
#endif
inline void OpProto::set_comment(const char *value) {
GOOGLE_DCHECK(value != NULL);
set_has_comment();
comment_.SetNoArena(
&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
::std::string(value));
// @@protoc_insertion_point(field_set_char:paddle_mobile.framework.proto.OpProto.comment)
}
inline void OpProto::set_comment(const char *value, size_t size) {
set_has_comment();
comment_.SetNoArena(
&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
::std::string(reinterpret_cast<const char *>(value), size));
// @@protoc_insertion_point(field_set_pointer:paddle_mobile.framework.proto.OpProto.comment)
}
inline ::std::string *OpProto::mutable_comment() {
set_has_comment();
// @@protoc_insertion_point(field_mutable:paddle_mobile.framework.proto.OpProto.comment)
return comment_.MutableNoArena(
&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string *OpProto::release_comment() {
// @@protoc_insertion_point(field_release:paddle_mobile.framework.proto.OpProto.comment)
clear_has_comment();
return comment_.ReleaseNoArena(
&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void OpProto::set_allocated_comment(::std::string *comment) {
if (comment != NULL) {
set_has_comment();
} else {
clear_has_comment();
}
comment_.SetAllocatedNoArena(
&::google::protobuf::internal::GetEmptyStringAlreadyInited(), comment);
// @@protoc_insertion_point(field_set_allocated:paddle_mobile.framework.proto.OpProto.comment)
}
// -------------------------------------------------------------------
// VarType_TensorDesc
// required .paddle_mobile.framework.proto.VarType.Type data_type =
// 1;
inline bool VarType_TensorDesc::has_data_type() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void VarType_TensorDesc::set_has_data_type() {
_has_bits_[0] |= 0x00000001u;
}
inline void VarType_TensorDesc::clear_has_data_type() {
_has_bits_[0] &= ~0x00000001u;
}
inline void VarType_TensorDesc::clear_data_type() {
data_type_ = 0;
clear_has_data_type();
}
inline ::paddle_mobile::framework::proto::VarType_Type
VarType_TensorDesc::data_type() const {
// @@protoc_insertion_point(field_get:paddle_mobile.framework.proto.VarType.TensorDesc.data_type)
return static_cast<::paddle_mobile::framework::proto::VarType_Type>(
data_type_);
}
inline void VarType_TensorDesc::set_data_type(
::paddle_mobile::framework::proto::VarType_Type value) {
assert(::paddle_mobile::framework::proto::VarType_Type_IsValid(value));
set_has_data_type();
data_type_ = value;
// @@protoc_insertion_point(field_set:paddle_mobile.framework.proto.VarType.TensorDesc.data_type)
}
// repeated int64 dims = 2;
inline int VarType_TensorDesc::dims_size() const { return dims_.size(); }
inline void VarType_TensorDesc::clear_dims() { dims_.Clear(); }
inline ::google::protobuf::int64 VarType_TensorDesc::dims(int index) const {
// @@protoc_insertion_point(field_get:paddle_mobile.framework.proto.VarType.TensorDesc.dims)
return dims_.Get(index);
}
inline void VarType_TensorDesc::set_dims(int index,
::google::protobuf::int64 value) {
dims_.Set(index, value);
// @@protoc_insertion_point(field_set:paddle_mobile.framework.proto.VarType.TensorDesc.dims)
}
inline void VarType_TensorDesc::add_dims(::google::protobuf::int64 value) {
dims_.Add(value);
// @@protoc_insertion_point(field_add:paddle_mobile.framework.proto.VarType.TensorDesc.dims)
}
inline const ::google::protobuf::RepeatedField<::google::protobuf::int64>
&VarType_TensorDesc::dims() const {
// @@protoc_insertion_point(field_list:paddle_mobile.framework.proto.VarType.TensorDesc.dims)
return dims_;
}
inline ::google::protobuf::RepeatedField<::google::protobuf::int64>
*VarType_TensorDesc::mutable_dims() {
// @@protoc_insertion_point(field_mutable_list:paddle_mobile.framework.proto.VarType.TensorDesc.dims)
return &dims_;
}
// -------------------------------------------------------------------
// VarType_LoDTensorDesc
// required .paddle_mobile.framework.proto.VarType.TensorDesc tensor
// = 1;
inline bool VarType_LoDTensorDesc::has_tensor() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void VarType_LoDTensorDesc::set_has_tensor() {
_has_bits_[0] |= 0x00000001u;
}
inline void VarType_LoDTensorDesc::clear_has_tensor() {
_has_bits_[0] &= ~0x00000001u;
}
inline void VarType_LoDTensorDesc::clear_tensor() {
if (tensor_ != NULL)
tensor_->::paddle_mobile::framework::proto::VarType_TensorDesc::Clear();
clear_has_tensor();
}
inline const ::paddle_mobile::framework::proto::VarType_TensorDesc &
VarType_LoDTensorDesc::tensor() const {
const ::paddle_mobile::framework::proto::VarType_TensorDesc *p = tensor_;
// @@protoc_insertion_point(field_get:paddle_mobile.framework.proto.VarType.LoDTensorDesc.tensor)
return p != NULL
? *p
: *reinterpret_cast<
const ::paddle_mobile::framework::proto::VarType_TensorDesc
*>(&::paddle_mobile::framework::proto::
_VarType_TensorDesc_default_instance_);
}
inline ::paddle_mobile::framework::proto::VarType_TensorDesc *
VarType_LoDTensorDesc::mutable_tensor() {
set_has_tensor();
if (tensor_ == NULL) {
tensor_ = new ::paddle_mobile::framework::proto::VarType_TensorDesc;
}
// @@protoc_insertion_point(field_mutable:paddle_mobile.framework.proto.VarType.LoDTensorDesc.tensor)
return tensor_;
}
inline ::paddle_mobile::framework::proto::VarType_TensorDesc *
VarType_LoDTensorDesc::release_tensor() {
// @@protoc_insertion_point(field_release:paddle_mobile.framework.proto.VarType.LoDTensorDesc.tensor)
clear_has_tensor();
::paddle_mobile::framework::proto::VarType_TensorDesc *temp = tensor_;
tensor_ = NULL;
return temp;
}
inline void VarType_LoDTensorDesc::set_allocated_tensor(
::paddle_mobile::framework::proto::VarType_TensorDesc *tensor) {
delete tensor_;
tensor_ = tensor;
if (tensor) {
set_has_tensor();
} else {
clear_has_tensor();
}
// @@protoc_insertion_point(field_set_allocated:paddle_mobile.framework.proto.VarType.LoDTensorDesc.tensor)
}
// optional int32 lod_level = 2 [default = 0];
inline bool VarType_LoDTensorDesc::has_lod_level() const {
return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void VarType_LoDTensorDesc::set_has_lod_level() {
_has_bits_[0] |= 0x00000002u;
}
inline void VarType_LoDTensorDesc::clear_has_lod_level() {
_has_bits_[0] &= ~0x00000002u;
}
inline void VarType_LoDTensorDesc::clear_lod_level() {
lod_level_ = 0;
clear_has_lod_level();
}
inline ::google::protobuf::int32 VarType_LoDTensorDesc::lod_level() const {
// @@protoc_insertion_point(field_get:paddle_mobile.framework.proto.VarType.LoDTensorDesc.lod_level)
return lod_level_;
}
inline void VarType_LoDTensorDesc::set_lod_level(
::google::protobuf::int32 value) {
set_has_lod_level();
lod_level_ = value;
// @@protoc_insertion_point(field_set:paddle_mobile.framework.proto.VarType.LoDTensorDesc.lod_level)
}
// -------------------------------------------------------------------
// VarType_LoDTensorArrayDesc
// required .paddle_mobile.framework.proto.VarType.TensorDesc tensor
// = 1;
inline bool VarType_LoDTensorArrayDesc::has_tensor() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void VarType_LoDTensorArrayDesc::set_has_tensor() {
_has_bits_[0] |= 0x00000001u;
}
inline void VarType_LoDTensorArrayDesc::clear_has_tensor() {
_has_bits_[0] &= ~0x00000001u;
}
inline void VarType_LoDTensorArrayDesc::clear_tensor() {
if (tensor_ != NULL)
tensor_->::paddle_mobile::framework::proto::VarType_TensorDesc::Clear();
clear_has_tensor();
}
inline const ::paddle_mobile::framework::proto::VarType_TensorDesc &
VarType_LoDTensorArrayDesc::tensor() const {
const ::paddle_mobile::framework::proto::VarType_TensorDesc *p = tensor_;
// @@protoc_insertion_point(field_get:paddle_mobile.framework.proto.VarType.LoDTensorArrayDesc.tensor)
return p != NULL
? *p
: *reinterpret_cast<
const ::paddle_mobile::framework::proto::VarType_TensorDesc
*>(&::paddle_mobile::framework::proto::
_VarType_TensorDesc_default_instance_);
}
inline ::paddle_mobile::framework::proto::VarType_TensorDesc *
VarType_LoDTensorArrayDesc::mutable_tensor() {
set_has_tensor();
if (tensor_ == NULL) {
tensor_ = new ::paddle_mobile::framework::proto::VarType_TensorDesc;
}
// @@protoc_insertion_point(field_mutable:paddle_mobile.framework.proto.VarType.LoDTensorArrayDesc.tensor)
return tensor_;
}
inline ::paddle_mobile::framework::proto::VarType_TensorDesc *
VarType_LoDTensorArrayDesc::release_tensor() {
// @@protoc_insertion_point(field_release:paddle_mobile.framework.proto.VarType.LoDTensorArrayDesc.tensor)
clear_has_tensor();
::paddle_mobile::framework::proto::VarType_TensorDesc *temp = tensor_;
tensor_ = NULL;
return temp;
}
inline void VarType_LoDTensorArrayDesc::set_allocated_tensor(
::paddle_mobile::framework::proto::VarType_TensorDesc *tensor) {
delete tensor_;
tensor_ = tensor;
if (tensor) {
set_has_tensor();
} else {
clear_has_tensor();
}
// @@protoc_insertion_point(field_set_allocated:paddle_mobile.framework.proto.VarType.LoDTensorArrayDesc.tensor)
}
// optional int32 lod_level = 2 [default = 0];
inline bool VarType_LoDTensorArrayDesc::has_lod_level() const {
return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void VarType_LoDTensorArrayDesc::set_has_lod_level() {
_has_bits_[0] |= 0x00000002u;
}
inline void VarType_LoDTensorArrayDesc::clear_has_lod_level() {
_has_bits_[0] &= ~0x00000002u;
}
inline void VarType_LoDTensorArrayDesc::clear_lod_level() {
lod_level_ = 0;
clear_has_lod_level();
}
inline ::google::protobuf::int32 VarType_LoDTensorArrayDesc::lod_level() const {
// @@protoc_insertion_point(field_get:paddle_mobile.framework.proto.VarType.LoDTensorArrayDesc.lod_level)
return lod_level_;
}
inline void VarType_LoDTensorArrayDesc::set_lod_level(
::google::protobuf::int32 value) {
set_has_lod_level();
lod_level_ = value;
// @@protoc_insertion_point(field_set:paddle_mobile.framework.proto.VarType.LoDTensorArrayDesc.lod_level)
}
// -------------------------------------------------------------------
// VarType_ReaderDesc
// repeated .paddle_mobile.framework.proto.VarType.LoDTensorDesc
// lod_tensor = 1;
inline int VarType_ReaderDesc::lod_tensor_size() const {
return lod_tensor_.size();
}
inline void VarType_ReaderDesc::clear_lod_tensor() { lod_tensor_.Clear(); }
inline const ::paddle_mobile::framework::proto::VarType_LoDTensorDesc &
VarType_ReaderDesc::lod_tensor(int index) const {
// @@protoc_insertion_point(field_get:paddle_mobile.framework.proto.VarType.ReaderDesc.lod_tensor)
return lod_tensor_.Get(index);
}
inline ::paddle_mobile::framework::proto::VarType_LoDTensorDesc *
VarType_ReaderDesc::mutable_lod_tensor(int index) {
// @@protoc_insertion_point(field_mutable:paddle_mobile.framework.proto.VarType.ReaderDesc.lod_tensor)
return lod_tensor_.Mutable(index);
}
inline ::paddle_mobile::framework::proto::VarType_LoDTensorDesc *
VarType_ReaderDesc::add_lod_tensor() {
// @@protoc_insertion_point(field_add:paddle_mobile.framework.proto.VarType.ReaderDesc.lod_tensor)
return lod_tensor_.Add();
}
inline ::google::protobuf::RepeatedPtrField<
::paddle_mobile::framework::proto::VarType_LoDTensorDesc>
*VarType_ReaderDesc::mutable_lod_tensor() {
// @@protoc_insertion_point(field_mutable_list:paddle_mobile.framework.proto.VarType.ReaderDesc.lod_tensor)
return &lod_tensor_;
}
inline const ::google::protobuf::RepeatedPtrField<
::paddle_mobile::framework::proto::VarType_LoDTensorDesc>
&VarType_ReaderDesc::lod_tensor() const {
// @@protoc_insertion_point(field_list:paddle_mobile.framework.proto.VarType.ReaderDesc.lod_tensor)
return lod_tensor_;
}
// -------------------------------------------------------------------
// VarType_ChannelDesc
// required .paddle_mobile.framework.proto.VarType.Type data_type =
// 1;
inline bool VarType_ChannelDesc::has_data_type() const {
return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void VarType_ChannelDesc::set_has_data_type() {
_has_bits_[0] |= 0x00000002u;
}
inline void VarType_ChannelDesc::clear_has_data_type() {
_has_bits_[0] &= ~0x00000002u;
}
inline void VarType_ChannelDesc::clear_data_type() {
data_type_ = 0;
clear_has_data_type();
}
inline ::paddle_mobile::framework::proto::VarType_Type
VarType_ChannelDesc::data_type() const {
// @@protoc_insertion_point(field_get:paddle_mobile.framework.proto.VarType.ChannelDesc.data_type)
return static_cast<::paddle_mobile::framework::proto::VarType_Type>(
data_type_);
}
inline void VarType_ChannelDesc::set_data_type(
::paddle_mobile::framework::proto::VarType_Type value) {
assert(::paddle_mobile::framework::proto::VarType_Type_IsValid(value));
set_has_data_type();
data_type_ = value;
// @@protoc_insertion_point(field_set:paddle_mobile.framework.proto.VarType.ChannelDesc.data_type)
}
// required int64 capacity = 2;
inline bool VarType_ChannelDesc::has_capacity() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void VarType_ChannelDesc::set_has_capacity() {
_has_bits_[0] |= 0x00000001u;
}
inline void VarType_ChannelDesc::clear_has_capacity() {
_has_bits_[0] &= ~0x00000001u;
}
inline void VarType_ChannelDesc::clear_capacity() {
capacity_ = GOOGLE_LONGLONG(0);
clear_has_capacity();
}
inline ::google::protobuf::int64 VarType_ChannelDesc::capacity() const {
// @@protoc_insertion_point(field_get:paddle_mobile.framework.proto.VarType.ChannelDesc.capacity)
return capacity_;
}
inline void VarType_ChannelDesc::set_capacity(::google::protobuf::int64 value) {
set_has_capacity();
capacity_ = value;
// @@protoc_insertion_point(field_set:paddle_mobile.framework.proto.VarType.ChannelDesc.capacity)
}
// -------------------------------------------------------------------
// VarType_Tuple
// repeated .paddle_mobile.framework.proto.VarType.Type element_type
// = 1;
inline int VarType_Tuple::element_type_size() const {
return element_type_.size();
}
inline void VarType_Tuple::clear_element_type() { element_type_.Clear(); }
inline ::paddle_mobile::framework::proto::VarType_Type
VarType_Tuple::element_type(int index) const {
// @@protoc_insertion_point(field_get:paddle_mobile.framework.proto.VarType.Tuple.element_type)
return static_cast<::paddle_mobile::framework::proto::VarType_Type>(
element_type_.Get(index));
}
inline void VarType_Tuple::set_element_type(
int index, ::paddle_mobile::framework::proto::VarType_Type value) {
assert(::paddle_mobile::framework::proto::VarType_Type_IsValid(value));
element_type_.Set(index, value);
// @@protoc_insertion_point(field_set:paddle_mobile.framework.proto.VarType.Tuple.element_type)
}
inline void VarType_Tuple::add_element_type(
::paddle_mobile::framework::proto::VarType_Type value) {
assert(::paddle_mobile::framework::proto::VarType_Type_IsValid(value));
element_type_.Add(value);
// @@protoc_insertion_point(field_add:paddle_mobile.framework.proto.VarType.Tuple.element_type)
}
inline const ::google::protobuf::RepeatedField<int>
&VarType_Tuple::element_type() const {
// @@protoc_insertion_point(field_list:paddle_mobile.framework.proto.VarType.Tuple.element_type)
return element_type_;
}
inline ::google::protobuf::RepeatedField<int>
*VarType_Tuple::mutable_element_type() {
// @@protoc_insertion_point(field_mutable_list:paddle_mobile.framework.proto.VarType.Tuple.element_type)
return &element_type_;
}
// -------------------------------------------------------------------
// VarType
// required .paddle_mobile.framework.proto.VarType.Type type = 1;
inline bool VarType::has_type() const {
return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void VarType::set_has_type() { _has_bits_[0] |= 0x00000040u; }
inline void VarType::clear_has_type() { _has_bits_[0] &= ~0x00000040u; }
inline void VarType::clear_type() {
type_ = 0;
clear_has_type();
}
inline ::paddle_mobile::framework::proto::VarType_Type VarType::type() const {
// @@protoc_insertion_point(field_get:paddle_mobile.framework.proto.VarType.type)
return static_cast<::paddle_mobile::framework::proto::VarType_Type>(type_);
}
inline void VarType::set_type(
::paddle_mobile::framework::proto::VarType_Type value) {
assert(::paddle_mobile::framework::proto::VarType_Type_IsValid(value));
set_has_type();
type_ = value;
// @@protoc_insertion_point(field_set:paddle_mobile.framework.proto.VarType.type)
}
// optional .paddle_mobile.framework.proto.VarType.TensorDesc
// selected_rows = 2;
inline bool VarType::has_selected_rows() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void VarType::set_has_selected_rows() { _has_bits_[0] |= 0x00000001u; }
inline void VarType::clear_has_selected_rows() {
_has_bits_[0] &= ~0x00000001u;
}
inline void VarType::clear_selected_rows() {
if (selected_rows_ != NULL)
selected_rows_
->::paddle_mobile::framework::proto::VarType_TensorDesc::Clear();
clear_has_selected_rows();
}
inline const ::paddle_mobile::framework::proto::VarType_TensorDesc &
VarType::selected_rows() const {
const ::paddle_mobile::framework::proto::VarType_TensorDesc *p =
selected_rows_;
// @@protoc_insertion_point(field_get:paddle_mobile.framework.proto.VarType.selected_rows)
return p != NULL
? *p
: *reinterpret_cast<
const ::paddle_mobile::framework::proto::VarType_TensorDesc
*>(&::paddle_mobile::framework::proto::
_VarType_TensorDesc_default_instance_);
}
inline ::paddle_mobile::framework::proto::VarType_TensorDesc *
VarType::mutable_selected_rows() {
set_has_selected_rows();
if (selected_rows_ == NULL) {
selected_rows_ = new ::paddle_mobile::framework::proto::VarType_TensorDesc;
}
// @@protoc_insertion_point(field_mutable:paddle_mobile.framework.proto.VarType.selected_rows)
return selected_rows_;
}
inline ::paddle_mobile::framework::proto::VarType_TensorDesc *
VarType::release_selected_rows() {
// @@protoc_insertion_point(field_release:paddle_mobile.framework.proto.VarType.selected_rows)
clear_has_selected_rows();
::paddle_mobile::framework::proto::VarType_TensorDesc *temp = selected_rows_;
selected_rows_ = NULL;
return temp;
}
inline void VarType::set_allocated_selected_rows(
::paddle_mobile::framework::proto::VarType_TensorDesc *selected_rows) {
delete selected_rows_;
selected_rows_ = selected_rows;
if (selected_rows) {
set_has_selected_rows();
} else {
clear_has_selected_rows();
}
// @@protoc_insertion_point(field_set_allocated:paddle_mobile.framework.proto.VarType.selected_rows)
}
// optional .paddle_mobile.framework.proto.VarType.LoDTensorDesc
// lod_tensor = 3;
inline bool VarType::has_lod_tensor() const {
return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void VarType::set_has_lod_tensor() { _has_bits_[0] |= 0x00000002u; }
inline void VarType::clear_has_lod_tensor() { _has_bits_[0] &= ~0x00000002u; }
inline void VarType::clear_lod_tensor() {
if (lod_tensor_ != NULL)
lod_tensor_
->::paddle_mobile::framework::proto::VarType_LoDTensorDesc::Clear();
clear_has_lod_tensor();
}
inline const ::paddle_mobile::framework::proto::VarType_LoDTensorDesc &
VarType::lod_tensor() const {
const ::paddle_mobile::framework::proto::VarType_LoDTensorDesc *p =
lod_tensor_;
// @@protoc_insertion_point(field_get:paddle_mobile.framework.proto.VarType.lod_tensor)
return p != NULL ? *p
: *reinterpret_cast<const ::paddle_mobile::framework::proto::
VarType_LoDTensorDesc *>(
&::paddle_mobile::framework::proto::
_VarType_LoDTensorDesc_default_instance_);
}
inline ::paddle_mobile::framework::proto::VarType_LoDTensorDesc *
VarType::mutable_lod_tensor() {
set_has_lod_tensor();
if (lod_tensor_ == NULL) {
lod_tensor_ = new ::paddle_mobile::framework::proto::VarType_LoDTensorDesc;
}
// @@protoc_insertion_point(field_mutable:paddle_mobile.framework.proto.VarType.lod_tensor)
return lod_tensor_;
}
inline ::paddle_mobile::framework::proto::VarType_LoDTensorDesc *
VarType::release_lod_tensor() {
// @@protoc_insertion_point(field_release:paddle_mobile.framework.proto.VarType.lod_tensor)
clear_has_lod_tensor();
::paddle_mobile::framework::proto::VarType_LoDTensorDesc *temp = lod_tensor_;
lod_tensor_ = NULL;
return temp;
}
inline void VarType::set_allocated_lod_tensor(
::paddle_mobile::framework::proto::VarType_LoDTensorDesc *lod_tensor) {
delete lod_tensor_;
lod_tensor_ = lod_tensor;
if (lod_tensor) {
set_has_lod_tensor();
} else {
clear_has_lod_tensor();
}
// @@protoc_insertion_point(field_set_allocated:paddle_mobile.framework.proto.VarType.lod_tensor)
}
// optional
// .paddle_mobile.framework.proto.VarType.LoDTensorArrayDesc
// tensor_array = 4;
inline bool VarType::has_tensor_array() const {
return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void VarType::set_has_tensor_array() { _has_bits_[0] |= 0x00000004u; }
inline void VarType::clear_has_tensor_array() { _has_bits_[0] &= ~0x00000004u; }
inline void VarType::clear_tensor_array() {
if (tensor_array_ != NULL)
tensor_array_->::paddle_mobile::framework::proto::
VarType_LoDTensorArrayDesc::Clear();
clear_has_tensor_array();
}
inline const ::paddle_mobile::framework::proto::VarType_LoDTensorArrayDesc &
VarType::tensor_array() const {
const ::paddle_mobile::framework::proto::VarType_LoDTensorArrayDesc *p =
tensor_array_;
// @@protoc_insertion_point(field_get:paddle_mobile.framework.proto.VarType.tensor_array)
return p != NULL ? *p
: *reinterpret_cast<const ::paddle_mobile::framework::proto::
VarType_LoDTensorArrayDesc *>(
&::paddle_mobile::framework::proto::
_VarType_LoDTensorArrayDesc_default_instance_);
}
inline ::paddle_mobile::framework::proto::VarType_LoDTensorArrayDesc *
VarType::mutable_tensor_array() {
set_has_tensor_array();
if (tensor_array_ == NULL) {
tensor_array_ =
new ::paddle_mobile::framework::proto::VarType_LoDTensorArrayDesc;
}
// @@protoc_insertion_point(field_mutable:paddle_mobile.framework.proto.VarType.tensor_array)
return tensor_array_;
}
inline ::paddle_mobile::framework::proto::VarType_LoDTensorArrayDesc *
VarType::release_tensor_array() {
// @@protoc_insertion_point(field_release:paddle_mobile.framework.proto.VarType.tensor_array)
clear_has_tensor_array();
::paddle_mobile::framework::proto::VarType_LoDTensorArrayDesc *temp =
tensor_array_;
tensor_array_ = NULL;
return temp;
}
inline void VarType::set_allocated_tensor_array(
::paddle_mobile::framework::proto::VarType_LoDTensorArrayDesc
*tensor_array) {
delete tensor_array_;
tensor_array_ = tensor_array;
if (tensor_array) {
set_has_tensor_array();
} else {
clear_has_tensor_array();
}
// @@protoc_insertion_point(field_set_allocated:paddle_mobile.framework.proto.VarType.tensor_array)
}
// optional .paddle_mobile.framework.proto.VarType.ReaderDesc reader
// = 5;
inline bool VarType::has_reader() const {
return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void VarType::set_has_reader() { _has_bits_[0] |= 0x00000008u; }
inline void VarType::clear_has_reader() { _has_bits_[0] &= ~0x00000008u; }
inline void VarType::clear_reader() {
if (reader_ != NULL)
reader_->::paddle_mobile::framework::proto::VarType_ReaderDesc::Clear();
clear_has_reader();
}
inline const ::paddle_mobile::framework::proto::VarType_ReaderDesc &
VarType::reader() const {
const ::paddle_mobile::framework::proto::VarType_ReaderDesc *p = reader_;
// @@protoc_insertion_point(field_get:paddle_mobile.framework.proto.VarType.reader)
return p != NULL
? *p
: *reinterpret_cast<
const ::paddle_mobile::framework::proto::VarType_ReaderDesc
*>(&::paddle_mobile::framework::proto::
_VarType_ReaderDesc_default_instance_);
}
inline ::paddle_mobile::framework::proto::VarType_ReaderDesc *
VarType::mutable_reader() {
set_has_reader();
if (reader_ == NULL) {
reader_ = new ::paddle_mobile::framework::proto::VarType_ReaderDesc;
}
// @@protoc_insertion_point(field_mutable:paddle_mobile.framework.proto.VarType.reader)
return reader_;
}
inline ::paddle_mobile::framework::proto::VarType_ReaderDesc *
VarType::release_reader() {
// @@protoc_insertion_point(field_release:paddle_mobile.framework.proto.VarType.reader)
clear_has_reader();
::paddle_mobile::framework::proto::VarType_ReaderDesc *temp = reader_;
reader_ = NULL;
return temp;
}
inline void VarType::set_allocated_reader(
::paddle_mobile::framework::proto::VarType_ReaderDesc *reader) {
delete reader_;
reader_ = reader;
if (reader) {
set_has_reader();
} else {
clear_has_reader();
}
// @@protoc_insertion_point(field_set_allocated:paddle_mobile.framework.proto.VarType.reader)
}
// optional .paddle_mobile.framework.proto.VarType.ChannelDesc
// channel = 6;
inline bool VarType::has_channel() const {
return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void VarType::set_has_channel() { _has_bits_[0] |= 0x00000010u; }
inline void VarType::clear_has_channel() { _has_bits_[0] &= ~0x00000010u; }
inline void VarType::clear_channel() {
if (channel_ != NULL)
channel_->::paddle_mobile::framework::proto::VarType_ChannelDesc::Clear();
clear_has_channel();
}
inline const ::paddle_mobile::framework::proto::VarType_ChannelDesc &
VarType::channel() const {
const ::paddle_mobile::framework::proto::VarType_ChannelDesc *p = channel_;
// @@protoc_insertion_point(field_get:paddle_mobile.framework.proto.VarType.channel)
return p != NULL
? *p
: *reinterpret_cast<
const ::paddle_mobile::framework::proto::VarType_ChannelDesc
*>(&::paddle_mobile::framework::proto::
_VarType_ChannelDesc_default_instance_);
}
inline ::paddle_mobile::framework::proto::VarType_ChannelDesc *
VarType::mutable_channel() {
set_has_channel();
if (channel_ == NULL) {
channel_ = new ::paddle_mobile::framework::proto::VarType_ChannelDesc;
}
// @@protoc_insertion_point(field_mutable:paddle_mobile.framework.proto.VarType.channel)
return channel_;
}
inline ::paddle_mobile::framework::proto::VarType_ChannelDesc *
VarType::release_channel() {
// @@protoc_insertion_point(field_release:paddle_mobile.framework.proto.VarType.channel)
clear_has_channel();
::paddle_mobile::framework::proto::VarType_ChannelDesc *temp = channel_;
channel_ = NULL;
return temp;
}
inline void VarType::set_allocated_channel(
::paddle_mobile::framework::proto::VarType_ChannelDesc *channel) {
delete channel_;
channel_ = channel;
if (channel) {
set_has_channel();
} else {
clear_has_channel();
}
// @@protoc_insertion_point(field_set_allocated:paddle_mobile.framework.proto.VarType.channel)
}
// optional .paddle_mobile.framework.proto.VarType.Tuple tuple = 7;
inline bool VarType::has_tuple() const {
return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void VarType::set_has_tuple() { _has_bits_[0] |= 0x00000020u; }
inline void VarType::clear_has_tuple() { _has_bits_[0] &= ~0x00000020u; }
inline void VarType::clear_tuple() {
if (tuple_ != NULL)
tuple_->::paddle_mobile::framework::proto::VarType_Tuple::Clear();
clear_has_tuple();
}
inline const ::paddle_mobile::framework::proto::VarType_Tuple &VarType::tuple()
const {
const ::paddle_mobile::framework::proto::VarType_Tuple *p = tuple_;
// @@protoc_insertion_point(field_get:paddle_mobile.framework.proto.VarType.tuple)
return p != NULL
? *p
: *reinterpret_cast<
const ::paddle_mobile::framework::proto::VarType_Tuple *>(
&::paddle_mobile::framework::proto::
_VarType_Tuple_default_instance_);
}
inline ::paddle_mobile::framework::proto::VarType_Tuple *
VarType::mutable_tuple() {
set_has_tuple();
if (tuple_ == NULL) {
tuple_ = new ::paddle_mobile::framework::proto::VarType_Tuple;
}
// @@protoc_insertion_point(field_mutable:paddle_mobile.framework.proto.VarType.tuple)
return tuple_;
}
inline ::paddle_mobile::framework::proto::VarType_Tuple *
VarType::release_tuple() {
// @@protoc_insertion_point(field_release:paddle_mobile.framework.proto.VarType.tuple)
clear_has_tuple();
::paddle_mobile::framework::proto::VarType_Tuple *temp = tuple_;
tuple_ = NULL;
return temp;
}
inline void VarType::set_allocated_tuple(
::paddle_mobile::framework::proto::VarType_Tuple *tuple) {
delete tuple_;
tuple_ = tuple;
if (tuple) {
set_has_tuple();
} else {
clear_has_tuple();
}
// @@protoc_insertion_point(field_set_allocated:paddle_mobile.framework.proto.VarType.tuple)
}
// -------------------------------------------------------------------
// VarDesc
// required string name = 1;
inline bool VarDesc::has_name() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void VarDesc::set_has_name() { _has_bits_[0] |= 0x00000001u; }
inline void VarDesc::clear_has_name() { _has_bits_[0] &= ~0x00000001u; }
inline void VarDesc::clear_name() {
name_.ClearToEmptyNoArena(
&::google::protobuf::internal::GetEmptyStringAlreadyInited());
clear_has_name();
}
inline const ::std::string &VarDesc::name() const {
// @@protoc_insertion_point(field_get:paddle_mobile.framework.proto.VarDesc.name)
return name_.GetNoArena();
}
inline void VarDesc::set_name(const ::std::string &value) {
set_has_name();
name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
value);
// @@protoc_insertion_point(field_set:paddle_mobile.framework.proto.VarDesc.name)
}
#if LANG_CXX11
inline void VarDesc::set_name(::std::string &&value) {
set_has_name();
name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
::std::move(value));
// @@protoc_insertion_point(field_set_rvalue:paddle_mobile.framework.proto.VarDesc.name)
}
#endif
inline void VarDesc::set_name(const char *value) {
GOOGLE_DCHECK(value != NULL);
set_has_name();
name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
::std::string(value));
// @@protoc_insertion_point(field_set_char:paddle_mobile.framework.proto.VarDesc.name)
}
inline void VarDesc::set_name(const char *value, size_t size) {
set_has_name();
name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
::std::string(reinterpret_cast<const char *>(value), size));
// @@protoc_insertion_point(field_set_pointer:paddle_mobile.framework.proto.VarDesc.name)
}
inline ::std::string *VarDesc::mutable_name() {
set_has_name();
// @@protoc_insertion_point(field_mutable:paddle_mobile.framework.proto.VarDesc.name)
return name_.MutableNoArena(
&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string *VarDesc::release_name() {
// @@protoc_insertion_point(field_release:paddle_mobile.framework.proto.VarDesc.name)
clear_has_name();
return name_.ReleaseNoArena(
&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void VarDesc::set_allocated_name(::std::string *name) {
if (name != NULL) {
set_has_name();
} else {
clear_has_name();
}
name_.SetAllocatedNoArena(
&::google::protobuf::internal::GetEmptyStringAlreadyInited(), name);
// @@protoc_insertion_point(field_set_allocated:paddle_mobile.framework.proto.VarDesc.name)
}
// required .paddle_mobile.framework.proto.VarType type = 2;
inline bool VarDesc::has_type() const {
return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void VarDesc::set_has_type() { _has_bits_[0] |= 0x00000002u; }
inline void VarDesc::clear_has_type() { _has_bits_[0] &= ~0x00000002u; }
inline void VarDesc::clear_type() {
if (type_ != NULL) type_->::paddle_mobile::framework::proto::VarType::Clear();
clear_has_type();
}
inline const ::paddle_mobile::framework::proto::VarType &VarDesc::type() const {
const ::paddle_mobile::framework::proto::VarType *p = type_;
// @@protoc_insertion_point(field_get:paddle_mobile.framework.proto.VarDesc.type)
return p != NULL ? *p
: *reinterpret_cast<
const ::paddle_mobile::framework::proto::VarType *>(
&::paddle_mobile::framework::proto::
_VarType_default_instance_);
}
inline ::paddle_mobile::framework::proto::VarType *VarDesc::mutable_type() {
set_has_type();
if (type_ == NULL) {
type_ = new ::paddle_mobile::framework::proto::VarType;
}
// @@protoc_insertion_point(field_mutable:paddle_mobile.framework.proto.VarDesc.type)
return type_;
}
inline ::paddle_mobile::framework::proto::VarType *VarDesc::release_type() {
// @@protoc_insertion_point(field_release:paddle_mobile.framework.proto.VarDesc.type)
clear_has_type();
::paddle_mobile::framework::proto::VarType *temp = type_;
type_ = NULL;
return temp;
}
inline void VarDesc::set_allocated_type(
::paddle_mobile::framework::proto::VarType *type) {
delete type_;
type_ = type;
if (type) {
set_has_type();
} else {
clear_has_type();
}
// @@protoc_insertion_point(field_set_allocated:paddle_mobile.framework.proto.VarDesc.type)
}
// optional bool persistable = 3 [default = false];
inline bool VarDesc::has_persistable() const {
return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void VarDesc::set_has_persistable() { _has_bits_[0] |= 0x00000004u; }
inline void VarDesc::clear_has_persistable() { _has_bits_[0] &= ~0x00000004u; }
inline void VarDesc::clear_persistable() {
persistable_ = false;
clear_has_persistable();
}
inline bool VarDesc::persistable() const {
// @@protoc_insertion_point(field_get:paddle_mobile.framework.proto.VarDesc.persistable)
return persistable_;
}
inline void VarDesc::set_persistable(bool value) {
set_has_persistable();
persistable_ = value;
// @@protoc_insertion_point(field_set:paddle_mobile.framework.proto.VarDesc.persistable)
}
// -------------------------------------------------------------------
// BlockDesc
// required int32 idx = 1;
inline bool BlockDesc::has_idx() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void BlockDesc::set_has_idx() { _has_bits_[0] |= 0x00000001u; }
inline void BlockDesc::clear_has_idx() { _has_bits_[0] &= ~0x00000001u; }
inline void BlockDesc::clear_idx() {
idx_ = 0;
clear_has_idx();
}
inline ::google::protobuf::int32 BlockDesc::idx() const {
// @@protoc_insertion_point(field_get:paddle_mobile.framework.proto.BlockDesc.idx)
return idx_;
}
inline void BlockDesc::set_idx(::google::protobuf::int32 value) {
set_has_idx();
idx_ = value;
// @@protoc_insertion_point(field_set:paddle_mobile.framework.proto.BlockDesc.idx)
}
// required int32 parent_idx = 2;
inline bool BlockDesc::has_parent_idx() const {
return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void BlockDesc::set_has_parent_idx() { _has_bits_[0] |= 0x00000002u; }
inline void BlockDesc::clear_has_parent_idx() { _has_bits_[0] &= ~0x00000002u; }
inline void BlockDesc::clear_parent_idx() {
parent_idx_ = 0;
clear_has_parent_idx();
}
inline ::google::protobuf::int32 BlockDesc::parent_idx() const {
// @@protoc_insertion_point(field_get:paddle_mobile.framework.proto.BlockDesc.parent_idx)
return parent_idx_;
}
inline void BlockDesc::set_parent_idx(::google::protobuf::int32 value) {
set_has_parent_idx();
parent_idx_ = value;
// @@protoc_insertion_point(field_set:paddle_mobile.framework.proto.BlockDesc.parent_idx)
}
// repeated .paddle_mobile.framework.proto.VarDesc vars = 3;
inline int BlockDesc::vars_size() const { return vars_.size(); }
inline void BlockDesc::clear_vars() { vars_.Clear(); }
inline const ::paddle_mobile::framework::proto::VarDesc &BlockDesc::vars(
int index) const {
// @@protoc_insertion_point(field_get:paddle_mobile.framework.proto.BlockDesc.vars)
return vars_.Get(index);
}
inline ::paddle_mobile::framework::proto::VarDesc *BlockDesc::mutable_vars(
int index) {
// @@protoc_insertion_point(field_mutable:paddle_mobile.framework.proto.BlockDesc.vars)
return vars_.Mutable(index);
}
inline ::paddle_mobile::framework::proto::VarDesc *BlockDesc::add_vars() {
// @@protoc_insertion_point(field_add:paddle_mobile.framework.proto.BlockDesc.vars)
return vars_.Add();
}
inline ::google::protobuf::RepeatedPtrField<
::paddle_mobile::framework::proto::VarDesc>
*BlockDesc::mutable_vars() {
// @@protoc_insertion_point(field_mutable_list:paddle_mobile.framework.proto.BlockDesc.vars)
return &vars_;
}
inline const ::google::protobuf::RepeatedPtrField<
::paddle_mobile::framework::proto::VarDesc>
&BlockDesc::vars() const {
// @@protoc_insertion_point(field_list:paddle_mobile.framework.proto.BlockDesc.vars)
return vars_;
}
// repeated .paddle_mobile.framework.proto.OpDesc ops = 4;
inline int BlockDesc::ops_size() const { return ops_.size(); }
inline void BlockDesc::clear_ops() { ops_.Clear(); }
inline const ::paddle_mobile::framework::proto::OpDesc &BlockDesc::ops(
int index) const {
// @@protoc_insertion_point(field_get:paddle_mobile.framework.proto.BlockDesc.ops)
return ops_.Get(index);
}
inline ::paddle_mobile::framework::proto::OpDesc *BlockDesc::mutable_ops(
int index) {
// @@protoc_insertion_point(field_mutable:paddle_mobile.framework.proto.BlockDesc.ops)
return ops_.Mutable(index);
}
inline ::paddle_mobile::framework::proto::OpDesc *BlockDesc::add_ops() {
// @@protoc_insertion_point(field_add:paddle_mobile.framework.proto.BlockDesc.ops)
return ops_.Add();
}
inline ::google::protobuf::RepeatedPtrField<
::paddle_mobile::framework::proto::OpDesc>
*BlockDesc::mutable_ops() {
// @@protoc_insertion_point(field_mutable_list:paddle_mobile.framework.proto.BlockDesc.ops)
return &ops_;
}
inline const ::google::protobuf::RepeatedPtrField<
::paddle_mobile::framework::proto::OpDesc>
&BlockDesc::ops() const {
// @@protoc_insertion_point(field_list:paddle_mobile.framework.proto.BlockDesc.ops)
return ops_;
}
// optional int32 forward_block_idx = 5 [default = -1];
inline bool BlockDesc::has_forward_block_idx() const {
return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void BlockDesc::set_has_forward_block_idx() {
_has_bits_[0] |= 0x00000004u;
}
inline void BlockDesc::clear_has_forward_block_idx() {
_has_bits_[0] &= ~0x00000004u;
}
inline void BlockDesc::clear_forward_block_idx() {
forward_block_idx_ = -1;
clear_has_forward_block_idx();
}
inline ::google::protobuf::int32 BlockDesc::forward_block_idx() const {
// @@protoc_insertion_point(field_get:paddle_mobile.framework.proto.BlockDesc.forward_block_idx)
return forward_block_idx_;
}
inline void BlockDesc::set_forward_block_idx(::google::protobuf::int32 value) {
set_has_forward_block_idx();
forward_block_idx_ = value;
// @@protoc_insertion_point(field_set:paddle_mobile.framework.proto.BlockDesc.forward_block_idx)
}
// -------------------------------------------------------------------
// ProgramDesc
// repeated .paddle_mobile.framework.proto.BlockDesc blocks = 1;
inline int ProgramDesc::blocks_size() const { return blocks_.size(); }
inline void ProgramDesc::clear_blocks() { blocks_.Clear(); }
inline const ::paddle_mobile::framework::proto::BlockDesc &ProgramDesc::blocks(
int index) const {
// @@protoc_insertion_point(field_get:paddle_mobile.framework.proto.ProgramDesc.blocks)
return blocks_.Get(index);
}
inline ::paddle_mobile::framework::proto::BlockDesc *
ProgramDesc::mutable_blocks(int index) {
// @@protoc_insertion_point(field_mutable:paddle_mobile.framework.proto.ProgramDesc.blocks)
return blocks_.Mutable(index);
}
inline ::paddle_mobile::framework::proto::BlockDesc *ProgramDesc::add_blocks() {
// @@protoc_insertion_point(field_add:paddle_mobile.framework.proto.ProgramDesc.blocks)
return blocks_.Add();
}
inline ::google::protobuf::RepeatedPtrField<
::paddle_mobile::framework::proto::BlockDesc>
*ProgramDesc::mutable_blocks() {
// @@protoc_insertion_point(field_mutable_list:paddle_mobile.framework.proto.ProgramDesc.blocks)
return &blocks_;
}
inline const ::google::protobuf::RepeatedPtrField<
::paddle_mobile::framework::proto::BlockDesc>
&ProgramDesc::blocks() const {
// @@protoc_insertion_point(field_list:paddle_mobile.framework.proto.ProgramDesc.blocks)
return blocks_;
}
#ifdef __GNUC__
#pragma GCC diagnostic pop
#endif // __GNUC__
#endif // !PROTOBUF_INLINE_NOT_IN_HEADERS
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// @@protoc_insertion_point(namespace_scope)
} // namespace proto
} // namespace framework
} // namespace paddle_mobile
namespace google {
namespace protobuf {
template <>
struct is_proto_enum<::paddle_mobile::framework::proto::VarType_Type>
: ::google::protobuf::internal::true_type {};
template <>
struct is_proto_enum<::paddle_mobile::framework::proto::AttrType>
: ::google::protobuf::internal::true_type {};
} // namespace protobuf
} // namespace google
// @@protoc_insertion_point(global_scope)
#endif // PROTOBUF_framework_2eproto__INCLUDED
...@@ -244,58 +244,5 @@ void AppendLoD(LoD *lod, const LoD &lod_length) { ...@@ -244,58 +244,5 @@ void AppendLoD(LoD *lod, const LoD &lod_length) {
} }
} }
void SerializeToStream(std::ostream &os, const LoDTensor &tensor) {
{ // the 1st field, uint32_t version for LoDTensor
constexpr uint32_t version = 0;
os.write(reinterpret_cast<const char *>(&version), sizeof(version));
}
{
// the 2st field, LoD information
// uint64_t lod_level
// uint64_t lod_level_1 size in byte.
// int* lod_level_1 data
// ...
auto lod = tensor.lod();
uint64_t size = lod.size();
os.write(reinterpret_cast<const char *>(&size), sizeof(size));
for (auto &each : lod) {
size = each.size() * sizeof(framework::LoD::value_type::value_type);
os.write(reinterpret_cast<const char *>(&size), sizeof(size));
os.write(reinterpret_cast<const char *>(each.data()),
static_cast<std::streamsize>(size));
}
}
// the 3st field, Tensor
TensorToStream(os, static_cast<Tensor>(tensor));
}
void DeserializeFromStream(std::istream &is, LoDTensor *tensor) {
{
// the 1st field, unit32_t version for LoDTensor
uint32_t version;
is.read(reinterpret_cast<char *>(&version), sizeof(version));
// PADDLE_ENFORCE_EQ(version, 0U, "Only version 0 is
// supported");
}
{
// the 2st field, LoD information
uint64_t lod_level;
is.read(reinterpret_cast<char *>(&lod_level), sizeof(lod_level));
auto &lod = *tensor->mutable_lod();
lod.resize(lod_level);
for (uint64_t i = 0; i < lod_level; ++i) {
uint64_t size;
is.read(reinterpret_cast<char *>(&size), sizeof(size));
std::vector<size_t> tmp(size / sizeof(size_t));
is.read(reinterpret_cast<char *>(tmp.data()),
static_cast<std::streamsize>(size));
lod[i] = tmp;
}
}
// the 3st filed, Tensor
TensorFromStream(is, static_cast<Tensor *>(tensor));
}
} // namespace framework } // namespace framework
} // namespace paddle_mobile } // namespace paddle_mobile
...@@ -17,7 +17,6 @@ limitations under the License. */ ...@@ -17,7 +17,6 @@ limitations under the License. */
#include <string> #include <string>
#include "common/log.h" #include "common/log.h"
#include "common/type_define.h" #include "common/type_define.h"
#include "framework/framework.pb.h"
namespace paddle_mobile { namespace paddle_mobile {
namespace framework { namespace framework {
......
...@@ -15,7 +15,7 @@ limitations under the License. */ ...@@ -15,7 +15,7 @@ limitations under the License. */
#pragma once #pragma once
#include "framework/data_layout.h" #include "framework/data_layout.h"
#include "framework/framework.pb.h" #include "framework/program/tensor_desc.h"
namespace paddle_mobile { namespace paddle_mobile {
namespace framework { namespace framework {
...@@ -33,10 +33,10 @@ struct OpKernelType { ...@@ -33,10 +33,10 @@ struct OpKernelType {
// place, data_type, library_type kinds less than 2^8 // place, data_type, library_type kinds less than 2^8
constexpr static int LEFT_SHIFT = 8; constexpr static int LEFT_SHIFT = 8;
proto::VarType::Type data_type_; VarType_Type data_type_;
DataLayout data_layout_; DataLayout data_layout_;
OpKernelType(proto::VarType::Type data_type, OpKernelType(VarType_Type data_type,
DataLayout data_layout = DataLayout::kAnyLayout) DataLayout data_layout = DataLayout::kAnyLayout)
: data_type_(data_type), data_layout_(data_layout) {} : data_type_(data_type), data_layout_(data_layout) {}
......
...@@ -14,7 +14,6 @@ limitations under the License. */ ...@@ -14,7 +14,6 @@ limitations under the License. */
#pragma once #pragma once
#include "framework/framework.pb.h"
#include "framework/framework.pb-c.h" #include "framework/framework.pb-c.h"
#include "framework/program/op_desc.h" #include "framework/program/op_desc.h"
#include "framework/program/var_desc.h" #include "framework/program/var_desc.h"
......
...@@ -19,7 +19,6 @@ limitations under the License. */ ...@@ -19,7 +19,6 @@ limitations under the License. */
#include "common/log.h" #include "common/log.h"
#include "common/type_define.h" #include "common/type_define.h"
#include "framework/framework.pb.h"
#include "framework/framework.pb-c.h" #include "framework/framework.pb-c.h"
#include "framework/paddle_mobile_object.h" #include "framework/paddle_mobile_object.h"
......
...@@ -14,7 +14,6 @@ limitations under the License. */ ...@@ -14,7 +14,6 @@ limitations under the License. */
#pragma once #pragma once
#include "framework/framework.pb.h"
#include "framework/framework.pb-c.h" #include "framework/framework.pb-c.h"
#include "framework/program/tensor_desc.h" #include "framework/program/tensor_desc.h"
#include "framework/paddle_mobile_object.h" #include "framework/paddle_mobile_object.h"
......
...@@ -132,37 +132,6 @@ bool TensorContainsInf(const framework::Tensor &tensor) { ...@@ -132,37 +132,6 @@ bool TensorContainsInf(const framework::Tensor &tensor) {
return Any(tensor, predicate); return Any(tensor, predicate);
} }
void TensorToStream(std::ostream &os, const Tensor &tensor) {
{ // the 1st field, uint32_t version
constexpr uint32_t version = 0;
os.write(reinterpret_cast<const char *>(&version), sizeof(version));
}
{ // the 2nd field, tensor description
// int32_t size
// void* protobuf message
proto::VarType::TensorDesc desc;
desc.set_data_type(framework::ToDataType(tensor.type()));
auto dims = framework::vectorize(tensor.dims());
auto *pb_dims = desc.mutable_dims();
pb_dims->Resize(static_cast<int>(dims.size()), 0);
std::copy(dims.begin(), dims.end(), pb_dims->begin());
int32_t size = desc.ByteSize();
os.write(reinterpret_cast<const char *>(&size), sizeof(size));
auto out = desc.SerializeAsString();
os.write(out.data(), size);
}
{ // the 3rd field, tensor data
uint64_t size = tensor.memory_size();
auto *data_ptr = tensor.data<void>();
// PADDLE_ENFORCE(size <
// std::numeric_limits<std::streamsize>::max(),
// "Index overflow when writing tensor");
os.write(static_cast<const char *>(data_ptr),
static_cast<std::streamsize>(size));
}
}
struct DeserializedDataFunctor { struct DeserializedDataFunctor {
DeserializedDataFunctor(void **buf, Tensor *tensor) DeserializedDataFunctor(void **buf, Tensor *tensor)
: buf_(buf), tensor_(tensor) {} : buf_(buf), tensor_(tensor) {}
...@@ -176,32 +145,5 @@ struct DeserializedDataFunctor { ...@@ -176,32 +145,5 @@ struct DeserializedDataFunctor {
Tensor *tensor_; Tensor *tensor_;
}; };
void TensorFromStream(std::istream &is, framework::Tensor *tensor) {
uint32_t version;
is.read(reinterpret_cast<char *>(&version), sizeof(version));
// PADDLE_ENFORCE_EQ(version, 0U, "Only version 0 is supported");
proto::VarType::TensorDesc desc;
{ // int32_t size
// proto buffer
int32_t size;
is.read(reinterpret_cast<char *>(&size), sizeof(size));
std::unique_ptr<char[]> buf(new char[size]);
is.read(reinterpret_cast<char *>(buf.get()), size);
// PADDLE_ENFORCE(desc.ParseFromArray(buf.get(), size),
// "Cannot parse tensor desc");
}
{ // read tensor
std::vector<int64_t> dims;
dims.reserve(static_cast<size_t>(desc.dims().size()));
std::copy(desc.dims().begin(), desc.dims().end(), std::back_inserter(dims));
tensor->Resize(framework::make_ddim(dims));
void *buf;
framework::VisitDataType(desc.data_type(),
DeserializedDataFunctor(&buf, tensor));
is.read(static_cast<char *>(buf), tensor->memory_size());
}
}
} // namespace framework } // namespace framework
} // namespace paddle_mobile } // namespace paddle_mobile
...@@ -14,7 +14,6 @@ limitations under the License. */ ...@@ -14,7 +14,6 @@ limitations under the License. */
#pragma once #pragma once
#include <vector> #include <vector>
#include "framework.pb.h"
#include "memory/t_malloc.h" #include "memory/t_malloc.h"
#include "platform/data_type.h" #include "platform/data_type.h"
#include "tensor.h" #include "tensor.h"
......
...@@ -22,7 +22,6 @@ limitations under the License. */ ...@@ -22,7 +22,6 @@ limitations under the License. */
#include "framework/tensor.h" #include "framework/tensor.h"
#include "framework/operator.h" #include "framework/operator.h"
#include "framework/lod_tensor.h" #include "framework/lod_tensor.h"
#include "framework/framework.pb.h"
#include "framework/framework.pb-c.h" #include "framework/framework.pb-c.h"
#include "framework/program/var_desc.h" #include "framework/program/var_desc.h"
#include "framework/program/program_desc.h" #include "framework/program/program_desc.h"
...@@ -110,6 +109,14 @@ void Loader<Dtype, P>::LoadVar(framework::Variable *variable, const framework::V ...@@ -110,6 +109,14 @@ void Loader<Dtype, P>::LoadVar(framework::Variable *variable, const framework::V
const framework::TensorDesc &desc = var_desc.Tensor_desc(); const framework::TensorDesc &desc = var_desc.Tensor_desc();
PaddleMobile__Framework__Proto__VarType__TensorDesc *tensor_desc = NULL;
// void *v;
// PaddleMobile__Framework__Proto__VarType__TensorDesc_Closure()(tensor_desc, buf.get());
// DLOG << "PaddleMobile__Framework__Proto__VarType__TensorDesc_Closure- " << tensor_desc;
// framework::TensorDesc &tensor_desc = variable-> // framework::TensorDesc &tensor_desc = variable->
// PaddleMobile__Framework__Proto__ProgramDesc *c_program; // PaddleMobile__Framework__Proto__ProgramDesc *c_program;
// uint8_t *proto_buf = NULL; // uint8_t *proto_buf = NULL;
...@@ -240,7 +247,7 @@ Executor<Dtype, P>::Executor(const framework::Program<Dtype> p) : program_(p) { ...@@ -240,7 +247,7 @@ Executor<Dtype, P>::Executor(const framework::Program<Dtype> p) : program_(p) {
} }
template <typename Dtype, Precision P> template <typename Dtype, Precision P>
void Executor<Dtype, P>::LoadMemory(framework::LoDTensor *tensor, void Executor<Dtype, P>::LoadMemory(const framework::VarDesc var_desc, framework::LoDTensor *tensor,
const std::string &file_path) { const std::string &file_path) {
std::ifstream is(file_path); std::ifstream is(file_path);
PADDLE_MOBILE_ENFORCE(is.is_open(), "open file: %s failed", PADDLE_MOBILE_ENFORCE(is.is_open(), "open file: %s failed",
...@@ -281,39 +288,36 @@ void Executor<Dtype, P>::LoadMemory(framework::LoDTensor *tensor, ...@@ -281,39 +288,36 @@ void Executor<Dtype, P>::LoadMemory(framework::LoDTensor *tensor,
std::unique_ptr<char[]> buf(new char[size]); std::unique_ptr<char[]> buf(new char[size]);
is.read(reinterpret_cast<char *>(buf.get()), size); is.read(reinterpret_cast<char *>(buf.get()), size);
framework::proto::VarType::TensorDesc desc; const framework::TensorDesc &desc = var_desc.Tensor_desc();
desc.ParseFromArray(buf.get(), size);
int memory_size = 1; int memory_size = 1;
for (auto l : desc.dims()) { for (auto l : desc.Dims()) {
memory_size *= l; memory_size *= l;
} }
std::vector<int64_t> dims; tensor->Resize(framework::make_ddim(desc.Dims()));
dims.reserve(static_cast<size_t>(desc.dims().size()));
std::copy(desc.dims().begin(), desc.dims().end(), std::back_inserter(dims));
tensor->Resize(framework::make_ddim(dims));
void *memory = tensor; void *memory = tensor;
int type_size = 0; int type_size = 0;
switch (desc.data_type()) { switch (desc.DataType()) {
case framework::proto::VarType::FP16: case framework::VARTYPE_TYPE_FP16:
type_size = 2; type_size = 2;
break; break;
case framework::proto::VarType::FP32: case framework::VARTYPE_TYPE_FP32:
type_size = 4; type_size = 4;
memory = tensor->mutable_data<float>(); memory = tensor->mutable_data<float>();
break; break;
case framework::proto::VarType::FP64: case framework::VARTYPE_TYPE_FP64:
type_size = 8; type_size = 8;
break; break;
case framework::proto::VarType::INT32: case framework::VARTYPE_TYPE_INT32:
type_size = 4; type_size = 4;
break; break;
case framework::proto::VarType::INT64: case framework::VARTYPE_TYPE_INT64:
type_size = 8; type_size = 8;
break; break;
case framework::proto::VarType::BOOL: case framework::VARTYPE_TYPE_BOOL:
type_size = 1; type_size = 1;
break; break;
default: default:
...@@ -331,7 +335,7 @@ void Executor<Dtype, P>::InitMemory() { ...@@ -331,7 +335,7 @@ void Executor<Dtype, P>::InitMemory() {
auto var = program_.scope->Var(var_desc->Name()); auto var = program_.scope->Var(var_desc->Name());
if (var_desc->Persistable()) { if (var_desc->Persistable()) {
auto tensor = var->template GetMutable<framework::LoDTensor>(); auto tensor = var->template GetMutable<framework::LoDTensor>();
LoadMemory(tensor, program_.model_path + "/" + var_desc->Name()); LoadMemory(*var_desc, tensor, program_.model_path + "/" + var_desc->Name());
} else { } else {
if (var_desc->Type() == framework::VARTYPE_TYPE_LOD_TENSOR) { if (var_desc->Type() == framework::VARTYPE_TYPE_LOD_TENSOR) {
auto tensor = var->template GetMutable<framework::Tensor>(); auto tensor = var->template GetMutable<framework::Tensor>();
......
...@@ -52,7 +52,7 @@ class Executor { ...@@ -52,7 +52,7 @@ class Executor {
protected: protected:
void InitMemory(); void InitMemory();
void LoadMemory(framework::LoDTensor *tensor, const std::string &file_path); void LoadMemory(const framework::VarDesc var_desc, framework::LoDTensor *tensor, const std::string &file_path);
framework::Program<Dtype> program_; framework::Program<Dtype> program_;
std::shared_ptr<framework::ProgramDesc> to_predict_program_; std::shared_ptr<framework::ProgramDesc> to_predict_program_;
void predict(const framework::Tensor &t, int block_id); void predict(const framework::Tensor &t, int block_id);
......
...@@ -16,12 +16,13 @@ limitations under the License. */ ...@@ -16,12 +16,13 @@ limitations under the License. */
#include <string> #include <string>
#include <typeindex> #include <typeindex>
#include "framework/framework.pb.h"
#include "framework/program/tensor_desc.h"
namespace paddle_mobile { namespace paddle_mobile {
namespace framework { namespace framework {
inline proto::VarType::Type ToDataType(std::type_index type) { inline VarType_Type ToDataType(std::type_index type) {
/*if (typeid(platform::float16).hash_code() == type.hash_code()) { /*if (typeid(platform::float16).hash_code() == type.hash_code()) {
return proto::VarType::FP16; return proto::VarType::FP16;
} else */ } else */
...@@ -31,34 +32,34 @@ inline proto::VarType::Type ToDataType(std::type_index type) { ...@@ -31,34 +32,34 @@ inline proto::VarType::Type ToDataType(std::type_index type) {
// One fix to this is to replace float with const float because // One fix to this is to replace float with const float because
// typeid(T) == typeid(const T) // typeid(T) == typeid(const T)
// http://en.cppreference.com/w/cpp/language/typeid // http://en.cppreference.com/w/cpp/language/typeid
return proto::VarType::FP32; return VARTYPE_TYPE_FP32;
} else if (typeid(const double).hash_code() == type.hash_code()) { } else if (typeid(const double).hash_code() == type.hash_code()) {
return proto::VarType::FP64; return VARTYPE_TYPE_FP64;
} else if (typeid(const int).hash_code() == type.hash_code()) { } else if (typeid(const int).hash_code() == type.hash_code()) {
return proto::VarType::INT32; return VARTYPE_TYPE_INT32;
} else if (typeid(const int64_t).hash_code() == type.hash_code()) { } else if (typeid(const int64_t).hash_code() == type.hash_code()) {
return proto::VarType::INT64; return VARTYPE_TYPE_INT64;
} else if (typeid(const bool).hash_code() == type.hash_code()) { } else if (typeid(const bool).hash_code() == type.hash_code()) {
return proto::VarType::BOOL; return VARTYPE_TYPE_BOOL;
} else { } else {
// PADDLE_THROW("Not supported"); // PADDLE_THROW("Not supported");
// std::cout << "Not supported"; // std::cout << "Not supported";
} }
} }
inline std::type_index ToTypeIndex(proto::VarType::Type type) { inline std::type_index ToTypeIndex(VarType_Type type) {
switch (type) { switch (type) {
// case proto::VarType::FP16: // case proto::VarType::FP16:
// return typeid(platform::float16); // return typeid(platform::float16);
case proto::VarType::FP32: case VARTYPE_TYPE_FP32:
return typeid(float); return typeid(float);
case proto::VarType::FP64: case VARTYPE_TYPE_FP64:
return typeid(double); return typeid(double);
case proto::VarType::INT32: case VARTYPE_TYPE_INT32:
return typeid(int); return typeid(int);
case proto::VarType::INT64: case VARTYPE_TYPE_INT64:
return typeid(int64_t); return typeid(int64_t);
case proto::VarType::BOOL: case VARTYPE_TYPE_BOOL:
return typeid(bool); return typeid(bool);
default: default:
// PADDLE_THROW("Not support type %d", type); // PADDLE_THROW("Not support type %d", type);
...@@ -67,24 +68,24 @@ inline std::type_index ToTypeIndex(proto::VarType::Type type) { ...@@ -67,24 +68,24 @@ inline std::type_index ToTypeIndex(proto::VarType::Type type) {
} }
template <typename Visitor> template <typename Visitor>
inline void VisitDataType(proto::VarType::Type type, Visitor visitor) { inline void VisitDataType(VarType_Type type, Visitor visitor) {
switch (type) { switch (type) {
// case proto::VarType::FP16: // case proto::VarType::FP16:
// visitor.template operator()<platform::float16>(); // visitor.template operator()<platform::float16>();
// break; // break;
case proto::VarType::FP32: case VARTYPE_TYPE_FP32:
visitor.template operator()<float>(); visitor.template operator()<float>();
break; break;
case proto::VarType::FP64: case VARTYPE_TYPE_FP64:
visitor.template operator()<double>(); visitor.template operator()<double>();
break; break;
case proto::VarType::INT32: case VARTYPE_TYPE_INT32:
visitor.template operator()<int>(); visitor.template operator()<int>();
break; break;
case proto::VarType::INT64: case VARTYPE_TYPE_INT64:
visitor.template operator()<int64_t>(); visitor.template operator()<int64_t>();
break; break;
case proto::VarType::BOOL: case VARTYPE_TYPE_BOOL:
visitor.template operator()<bool>(); visitor.template operator()<bool>();
break; break;
default: default:
...@@ -93,21 +94,21 @@ inline void VisitDataType(proto::VarType::Type type, Visitor visitor) { ...@@ -93,21 +94,21 @@ inline void VisitDataType(proto::VarType::Type type, Visitor visitor) {
} }
} }
inline std::string DataTypeToString(const proto::VarType::Type type) { inline std::string DataTypeToString(const VarType_Type type) {
switch (type) { switch (type) {
case proto::VarType::FP16: case VARTYPE_TYPE_FP16:
return "float16"; return "float16";
case proto::VarType::FP32: case VARTYPE_TYPE_FP32:
return "float32"; return "float32";
case proto::VarType::FP64: case VARTYPE_TYPE_FP64:
return "float64"; return "float64";
case proto::VarType::INT16: case VARTYPE_TYPE_INT16:
return "int16"; return "int16";
case proto::VarType::INT32: case VARTYPE_TYPE_INT32:
return "int32"; return "int32";
case proto::VarType::INT64: case VARTYPE_TYPE_INT64:
return "int64"; return "int64";
case proto::VarType::BOOL: case VARTYPE_TYPE_BOOL:
return "bool"; return "bool";
default: default:
// PADDLE_THROW("Not support type %d", type); // PADDLE_THROW("Not support type %d", type);
...@@ -116,7 +117,7 @@ inline std::string DataTypeToString(const proto::VarType::Type type) { ...@@ -116,7 +117,7 @@ inline std::string DataTypeToString(const proto::VarType::Type type) {
} }
inline std::ostream &operator<<(std::ostream &out, inline std::ostream &operator<<(std::ostream &out,
const proto::VarType::Type &type) { const VarType_Type &type) {
out << DataTypeToString(type); out << DataTypeToString(type);
return out; return out;
} }
......
...@@ -21,7 +21,6 @@ limitations under the License. */ ...@@ -21,7 +21,6 @@ limitations under the License. */
#include "./test_helper.h" #include "./test_helper.h"
#include "common/enforce.h" #include "common/enforce.h"
#include "common/log.h" #include "common/log.h"
#include "framework/framework.pb.h"
#include "framework/lod_tensor.h" #include "framework/lod_tensor.h"
#include "framework/operator.h" #include "framework/operator.h"
#include "framework/program/block_desc.h" #include "framework/program/block_desc.h"
......
Markdown is supported
0% .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑!
想要评论请 注册