update google protobuf to 3.21.10
myk002
parent
764b4c856a
commit
9dabf51ac7
@ -1,195 +1,351 @@
|
||||
project(protobuf)
|
||||
|
||||
set(HASH_MAP_H <unordered_map>)
|
||||
set(HASH_SET_H <unordered_map>)
|
||||
set(HASH_NAMESPACE std)
|
||||
set(HASH_MAP_CLASS unordered_map)
|
||||
set(HASH_SET_CLASS unordered_set)
|
||||
set(HAVE_HASH_MAP 1)
|
||||
set(HAVE_HASH_SET 1)
|
||||
|
||||
if(HAVE_HASH_MAP EQUAL 0)
|
||||
message(SEND_ERROR "Could not find a working hash map implementation. Please install GCC >= 4.4, and all necessary 32-bit C++ development libraries.")
|
||||
endif()
|
||||
# Minimum CMake required
|
||||
cmake_minimum_required(VERSION 3.5)
|
||||
|
||||
if(UNIX)
|
||||
find_package(Threads REQUIRED)
|
||||
if(protobuf_VERBOSE)
|
||||
message(STATUS "Protocol Buffers Configuring...")
|
||||
endif()
|
||||
|
||||
configure_file("${CMAKE_CURRENT_SOURCE_DIR}/config.h.in" "${CMAKE_CURRENT_BINARY_DIR}/config.h")
|
||||
|
||||
set(LIBPROTOBUF_LITE_HDRS
|
||||
google/protobuf/io/coded_stream.h
|
||||
google/protobuf/io/coded_stream_inl.h
|
||||
google/protobuf/stubs/common.h
|
||||
${CMAKE_CURRENT_BINARY_DIR}/config.h
|
||||
google/protobuf/extension_set.h
|
||||
google/protobuf/generated_message_util.h
|
||||
google/protobuf/stubs/hash.h
|
||||
google/protobuf/stubs/map-util.h
|
||||
google/protobuf/message_lite.h
|
||||
google/protobuf/stubs/once.h
|
||||
google/protobuf/repeated_field.h
|
||||
google/protobuf/stubs/stl_util-inl.h
|
||||
google/protobuf/wire_format_lite.h
|
||||
google/protobuf/wire_format_lite_inl.h
|
||||
google/protobuf/io/zero_copy_stream.h
|
||||
google/protobuf/io/zero_copy_stream_impl_lite.h
|
||||
google/protobuf/io/gzip_stream.h
|
||||
google/protobuf/io/zero_copy_stream_impl.h
|
||||
)
|
||||
|
||||
set(LIBPROTOBUF_FULL_HDRS
|
||||
google/protobuf/descriptor.h
|
||||
google/protobuf/descriptor.pb.h
|
||||
google/protobuf/descriptor_database.h
|
||||
google/protobuf/dynamic_message.h
|
||||
google/protobuf/generated_message_reflection.h
|
||||
google/protobuf/compiler/importer.h
|
||||
google/protobuf/message.h
|
||||
google/protobuf/compiler/parser.h
|
||||
google/protobuf/io/printer.h
|
||||
google/protobuf/reflection_ops.h
|
||||
google/protobuf/service.h
|
||||
google/protobuf/stubs/strutil.h
|
||||
google/protobuf/stubs/substitute.h
|
||||
google/protobuf/text_format.h
|
||||
google/protobuf/io/tokenizer.h
|
||||
google/protobuf/unknown_field_set.h
|
||||
google/protobuf/wire_format.h
|
||||
)
|
||||
|
||||
list(APPEND LIBPROTOBUF_FULL_HDRS ${LIBPROTOBUF_LITE_HDRS})
|
||||
|
||||
set(LIBPROTOBUF_LITE_SRCS
|
||||
google/protobuf/io/coded_stream.cc
|
||||
google/protobuf/stubs/common.cc
|
||||
google/protobuf/extension_set.cc
|
||||
google/protobuf/generated_message_util.cc
|
||||
google/protobuf/message_lite.cc
|
||||
google/protobuf/stubs/once.cc
|
||||
google/protobuf/repeated_field.cc
|
||||
google/protobuf/wire_format_lite.cc
|
||||
google/protobuf/io/zero_copy_stream.cc
|
||||
google/protobuf/io/zero_copy_stream_impl_lite.cc
|
||||
google/protobuf/io/gzip_stream.cc
|
||||
google/protobuf/io/zero_copy_stream_impl.cc
|
||||
)
|
||||
|
||||
set(LIBPROTOBUF_FULL_SRCS
|
||||
google/protobuf/descriptor.cc
|
||||
google/protobuf/descriptor.pb.cc
|
||||
google/protobuf/descriptor_database.cc
|
||||
google/protobuf/dynamic_message.cc
|
||||
google/protobuf/extension_set_heavy.cc
|
||||
google/protobuf/generated_message_reflection.cc
|
||||
google/protobuf/compiler/importer.cc
|
||||
google/protobuf/io/gzip_stream.cc
|
||||
google/protobuf/message.cc
|
||||
google/protobuf/compiler/parser.cc
|
||||
google/protobuf/io/printer.cc
|
||||
google/protobuf/reflection_ops.cc
|
||||
google/protobuf/service.cc
|
||||
google/protobuf/stubs/structurally_valid.cc
|
||||
google/protobuf/stubs/strutil.cc
|
||||
google/protobuf/stubs/substitute.cc
|
||||
google/protobuf/text_format.cc
|
||||
google/protobuf/io/tokenizer.cc
|
||||
google/protobuf/unknown_field_set.cc
|
||||
google/protobuf/wire_format.cc
|
||||
google/protobuf/io/zero_copy_stream_impl.cc
|
||||
)
|
||||
|
||||
set(LIBPROTOC_HDRS
|
||||
google/protobuf/compiler/code_generator.h
|
||||
google/protobuf/compiler/command_line_interface.h
|
||||
google/protobuf/compiler/cpp/cpp_enum.h
|
||||
google/protobuf/compiler/cpp/cpp_enum_field.h
|
||||
google/protobuf/compiler/cpp/cpp_extension.h
|
||||
google/protobuf/compiler/cpp/cpp_field.h
|
||||
google/protobuf/compiler/cpp/cpp_file.h
|
||||
google/protobuf/compiler/cpp/cpp_generator.h
|
||||
google/protobuf/compiler/cpp/cpp_helpers.h
|
||||
google/protobuf/compiler/cpp/cpp_message.h
|
||||
google/protobuf/compiler/cpp/cpp_message_field.h
|
||||
google/protobuf/compiler/cpp/cpp_primitive_field.h
|
||||
google/protobuf/compiler/cpp/cpp_service.h
|
||||
google/protobuf/compiler/cpp/cpp_string_field.h
|
||||
google/protobuf/compiler/plugin.h
|
||||
google/protobuf/compiler/plugin.pb.h
|
||||
google/protobuf/compiler/subprocess.h
|
||||
google/protobuf/compiler/zip_writer.h
|
||||
)
|
||||
|
||||
set(LIBPROTOC_SRCS
|
||||
google/protobuf/compiler/code_generator.cc
|
||||
google/protobuf/compiler/command_line_interface.cc
|
||||
google/protobuf/compiler/cpp/cpp_enum.cc
|
||||
google/protobuf/compiler/cpp/cpp_enum_field.cc
|
||||
google/protobuf/compiler/cpp/cpp_extension.cc
|
||||
google/protobuf/compiler/cpp/cpp_field.cc
|
||||
google/protobuf/compiler/cpp/cpp_file.cc
|
||||
google/protobuf/compiler/cpp/cpp_generator.cc
|
||||
google/protobuf/compiler/cpp/cpp_helpers.cc
|
||||
google/protobuf/compiler/cpp/cpp_message.cc
|
||||
google/protobuf/compiler/cpp/cpp_message_field.cc
|
||||
google/protobuf/compiler/cpp/cpp_primitive_field.cc
|
||||
google/protobuf/compiler/cpp/cpp_service.cc
|
||||
google/protobuf/compiler/cpp/cpp_string_field.cc
|
||||
google/protobuf/compiler/plugin.cc
|
||||
google/protobuf/compiler/plugin.pb.cc
|
||||
google/protobuf/compiler/subprocess.cc
|
||||
google/protobuf/compiler/zip_writer.cc
|
||||
)
|
||||
|
||||
list(APPEND LIBPROTOBUF_FULL_SRCS ${LIBPROTOBUF_LITE_SRCS})
|
||||
|
||||
if(CMAKE_COMPILER_IS_GNUCC)
|
||||
set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS_RELWITHDEBINFO}")
|
||||
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-unused-result -Wno-unused-local-typedefs -Wno-misleading-indentation -Wno-class-memaccess -Wno-sign-compare")
|
||||
elseif(MSVC)
|
||||
# Disable warnings for integer conversion to smaller type
|
||||
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /wd4267")
|
||||
# CMake policies
|
||||
cmake_policy(SET CMP0022 NEW)
|
||||
# On MacOS use @rpath/ for target's install name prefix path
|
||||
if (POLICY CMP0042)
|
||||
cmake_policy(SET CMP0042 NEW)
|
||||
endif ()
|
||||
# Clear VERSION variables when no VERSION is given to project()
|
||||
if(POLICY CMP0048)
|
||||
cmake_policy(SET CMP0048 NEW)
|
||||
endif()
|
||||
# MSVC runtime library flags are selected by an abstraction.
|
||||
if(POLICY CMP0091)
|
||||
cmake_policy(SET CMP0091 NEW)
|
||||
endif()
|
||||
|
||||
include_directories(${CMAKE_CURRENT_SOURCE_DIR})
|
||||
set(PROTOBUF_INCLUDE_DIRS ${CMAKE_CURRENT_SOURCE_DIR})
|
||||
include_directories(${ZLIB_INCLUDE_DIRS})
|
||||
include_directories(${CMAKE_CURRENT_BINARY_DIR})
|
||||
# Project
|
||||
project(protobuf C CXX)
|
||||
|
||||
# Protobuf shared libraries
|
||||
if(protobuf_DEPRECATED_CMAKE_SUBDIRECTORY_USAGE)
|
||||
if(CMAKE_PROJECT_NAME STREQUAL "protobuf")
|
||||
get_filename_component(CMAKE_SOURCE_DIR ${CMAKE_SOURCE_DIR} DIRECTORY)
|
||||
endif()
|
||||
get_filename_component(CMAKE_CURRENT_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR} DIRECTORY)
|
||||
get_filename_component(PROJECT_SOURCE_DIR ${PROJECT_SOURCE_DIR} DIRECTORY)
|
||||
get_filename_component(protobuf_SOURCE_DIR ${protobuf_SOURCE_DIR} DIRECTORY)
|
||||
endif()
|
||||
|
||||
add_library(protobuf SHARED ${LIBPROTOBUF_FULL_SRCS} ${LIBPROTOBUF_FULL_HDRS})
|
||||
ide_folder(protobuf "Depends")
|
||||
add_library(protobuf-lite SHARED ${LIBPROTOBUF_LITE_SRCS} ${LIBPROTOBUF_LITE_HDRS})
|
||||
ide_folder(protobuf-lite "Depends")
|
||||
# Add c++11 flags
|
||||
if (CYGWIN)
|
||||
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=gnu++11")
|
||||
else()
|
||||
set(CMAKE_CXX_STANDARD 11)
|
||||
set(CMAKE_CXX_STANDARD_REQUIRED ON)
|
||||
set(CMAKE_CXX_EXTENSIONS OFF)
|
||||
endif()
|
||||
|
||||
set_target_properties(protobuf PROPERTIES COMPILE_DEFINITIONS LIBPROTOBUF_EXPORTS)
|
||||
set_target_properties(protobuf-lite PROPERTIES COMPILE_DEFINITIONS LIBPROTOBUF_EXPORTS)
|
||||
# The Intel compiler isn't able to deal with noinline member functions of
|
||||
# template classes defined in headers. As such it spams the output with
|
||||
# warning #2196: routine is both "inline" and "noinline"
|
||||
# This silences that warning.
|
||||
if (CMAKE_CXX_COMPILER_ID MATCHES Intel)
|
||||
string(APPEND CMAKE_CXX_FLAGS " -diag-disable=2196")
|
||||
endif()
|
||||
|
||||
target_link_libraries(protobuf ${CMAKE_THREAD_LIBS_INIT} ${ZLIB_LIBRARIES})
|
||||
target_link_libraries(protobuf-lite ${CMAKE_THREAD_LIBS_INIT} ${ZLIB_LIBRARIES})
|
||||
# Options
|
||||
option(protobuf_INSTALL "Install protobuf binaries and files" ON)
|
||||
if(WITH_PROTOC)
|
||||
set(protobuf_PROTOC_EXE ${WITH_PROTOC} CACHE FILEPATH "Protocol Buffer Compiler executable" FORCE)
|
||||
endif()
|
||||
option(protobuf_BUILD_TESTS "Build tests" ON)
|
||||
option(protobuf_BUILD_CONFORMANCE "Build conformance tests" OFF)
|
||||
option(protobuf_BUILD_EXAMPLES "Build examples" OFF)
|
||||
option(protobuf_BUILD_PROTOC_BINARIES "Build libprotoc and protoc compiler" ON)
|
||||
option(protobuf_BUILD_LIBPROTOC "Build libprotoc" OFF)
|
||||
option(protobuf_DISABLE_RTTI "Remove runtime type information in the binaries" OFF)
|
||||
if (BUILD_SHARED_LIBS)
|
||||
set(protobuf_BUILD_SHARED_LIBS_DEFAULT ON)
|
||||
else (BUILD_SHARED_LIBS)
|
||||
set(protobuf_BUILD_SHARED_LIBS_DEFAULT OFF)
|
||||
endif (BUILD_SHARED_LIBS)
|
||||
option(protobuf_BUILD_SHARED_LIBS "Build Shared Libraries" ${protobuf_BUILD_SHARED_LIBS_DEFAULT})
|
||||
include(CMakeDependentOption)
|
||||
cmake_dependent_option(protobuf_MSVC_STATIC_RUNTIME "Link static runtime libraries" ON
|
||||
"NOT protobuf_BUILD_SHARED_LIBS" OFF)
|
||||
set(protobuf_WITH_ZLIB_DEFAULT ON)
|
||||
option(protobuf_WITH_ZLIB "Build with zlib support" ${protobuf_WITH_ZLIB_DEFAULT})
|
||||
set(protobuf_DEBUG_POSTFIX "d"
|
||||
CACHE STRING "Default debug postfix")
|
||||
mark_as_advanced(protobuf_DEBUG_POSTFIX)
|
||||
# User options
|
||||
include(${protobuf_SOURCE_DIR}/cmake/protobuf-options.cmake)
|
||||
|
||||
install(TARGETS protobuf-lite
|
||||
LIBRARY DESTINATION ${DFHACK_LIBRARY_DESTINATION}
|
||||
RUNTIME DESTINATION ${DFHACK_LIBRARY_DESTINATION})
|
||||
# Overrides for option dependencies
|
||||
if (protobuf_BUILD_PROTOC_BINARIES OR protobuf_BUILD_TESTS)
|
||||
set(protobuf_BUILD_LIBPROTOC ON)
|
||||
endif ()
|
||||
# Path to main configure script
|
||||
set(protobuf_CONFIGURE_SCRIPT "${protobuf_SOURCE_DIR}/configure.ac")
|
||||
|
||||
if(NOT CMAKE_CROSSCOMPILING)
|
||||
# Protobuf compiler shared library
|
||||
# Parse configure script
|
||||
set(protobuf_AC_INIT_REGEX
|
||||
"^AC_INIT\\(\\[([^]]+)\\],\\[([^]]+)\\],\\[([^]]+)\\],\\[([^]]+)\\]\\)$")
|
||||
file(STRINGS "${protobuf_CONFIGURE_SCRIPT}" protobuf_AC_INIT_LINE
|
||||
LIMIT_COUNT 1 REGEX "^AC_INIT")
|
||||
# Description
|
||||
string(REGEX REPLACE "${protobuf_AC_INIT_REGEX}" "\\1"
|
||||
protobuf_DESCRIPTION "${protobuf_AC_INIT_LINE}")
|
||||
# Version
|
||||
string(REGEX REPLACE "${protobuf_AC_INIT_REGEX}" "\\2"
|
||||
protobuf_VERSION_STRING "${protobuf_AC_INIT_LINE}")
|
||||
# Contact
|
||||
string(REGEX REPLACE "${protobuf_AC_INIT_REGEX}" "\\3"
|
||||
protobuf_CONTACT "${protobuf_AC_INIT_LINE}")
|
||||
# Parse version tweaks
|
||||
set(protobuf_VERSION_REGEX "^([0-9]+)\\.([0-9]+)\\.([0-9]+)([-]rc[-]|\\.)?([0-9]*)$")
|
||||
string(REGEX REPLACE "${protobuf_VERSION_REGEX}" "\\1"
|
||||
protobuf_VERSION_MAJOR "${protobuf_VERSION_STRING}")
|
||||
string(REGEX REPLACE "${protobuf_VERSION_REGEX}" "\\2"
|
||||
protobuf_VERSION_MINOR "${protobuf_VERSION_STRING}")
|
||||
string(REGEX REPLACE "${protobuf_VERSION_REGEX}" "\\3"
|
||||
protobuf_VERSION_PATCH "${protobuf_VERSION_STRING}")
|
||||
string(REGEX REPLACE "${protobuf_VERSION_REGEX}" "\\5"
|
||||
protobuf_VERSION_PRERELEASE "${protobuf_VERSION_STRING}")
|
||||
|
||||
add_library(protoc SHARED ${LIBPROTOC_SRCS} ${LIBPROTOC_HDRS})
|
||||
ide_folder(protoc "Depends")
|
||||
message(STATUS "${protobuf_VERSION_PRERELEASE}")
|
||||
|
||||
set_target_properties(protoc PROPERTIES COMPILE_DEFINITIONS LIBPROTOC_EXPORTS)
|
||||
target_link_libraries(protoc protobuf)
|
||||
# Package version
|
||||
set(protobuf_VERSION
|
||||
"${protobuf_VERSION_MAJOR}.${protobuf_VERSION_MINOR}.${protobuf_VERSION_PATCH}")
|
||||
|
||||
# Protobuf compiler executable
|
||||
if(protobuf_VERSION_PRERELEASE)
|
||||
set(protobuf_VERSION "${protobuf_VERSION}.${protobuf_VERSION_PRERELEASE}")
|
||||
else()
|
||||
set(protobuf_VERSION "${protobuf_VERSION}.0")
|
||||
endif()
|
||||
message(STATUS "${protobuf_VERSION}")
|
||||
|
||||
add_executable(protoc-bin google/protobuf/compiler/main.cc google/protobuf/compiler/command_line_interface.h google/protobuf/compiler/cpp/cpp_generator.h)
|
||||
ide_folder(protoc-bin "Depends")
|
||||
if(protobuf_VERBOSE)
|
||||
message(STATUS "Configuration script parsing status [")
|
||||
message(STATUS " Description : ${protobuf_DESCRIPTION}")
|
||||
message(STATUS " Version : ${protobuf_VERSION} (${protobuf_VERSION_STRING})")
|
||||
message(STATUS " Contact : ${protobuf_CONTACT}")
|
||||
message(STATUS "]")
|
||||
endif()
|
||||
|
||||
set_target_properties(protoc-bin PROPERTIES OUTPUT_NAME protoc)
|
||||
target_link_libraries(protoc-bin protoc)
|
||||
add_definitions(-DGOOGLE_PROTOBUF_CMAKE_BUILD)
|
||||
|
||||
export(TARGETS protoc-bin FILE ${CMAKE_BINARY_DIR}/ImportExecutables.cmake )
|
||||
if (protobuf_DISABLE_RTTI)
|
||||
add_definitions(-DGOOGLE_PROTOBUF_NO_RTTI=1)
|
||||
endif()
|
||||
|
||||
file(WRITE ${CMAKE_CURRENT_BINARY_DIR}/cmaketest.map
|
||||
"{
|
||||
global:
|
||||
main;
|
||||
local:
|
||||
*;
|
||||
};")
|
||||
# CheckLinkerFlag module available in CMake >=3.18.
|
||||
if(${CMAKE_VERSION} VERSION_GREATER 3.18 OR ${CMAKE_VERSION} VERSION_EQUAL 3.18)
|
||||
include(CheckLinkerFlag)
|
||||
check_linker_flag(CXX -Wl,--version-script=${CMAKE_CURRENT_BINARY_DIR}/cmaketest.map protobuf_HAVE_LD_VERSION_SCRIPT)
|
||||
else()
|
||||
include(CheckCXXSourceCompiles)
|
||||
set(OLD_CMAKE_REQUIRED_FLAGS ${CMAKE_REQUIRED_FLAGS})
|
||||
set(CMAKE_REQUIRED_FLAGS ${CMAKE_REQUIRED_FLAGS} -Wl,--version-script=${CMAKE_CURRENT_BINARY_DIR}/cmaketest.map)
|
||||
check_cxx_source_compiles("
|
||||
int main() {
|
||||
return 0;
|
||||
}
|
||||
" protobuf_HAVE_LD_VERSION_SCRIPT)
|
||||
set(CMAKE_REQUIRED_FLAGS ${OLD_CMAKE_REQUIRED_FLAGS})
|
||||
endif()
|
||||
file(REMOVE ${CMAKE_CURRENT_BINARY_DIR}/cmaketest.map)
|
||||
|
||||
find_package(Threads REQUIRED)
|
||||
|
||||
set(_protobuf_FIND_ZLIB)
|
||||
if (protobuf_WITH_ZLIB)
|
||||
find_package(ZLIB)
|
||||
if (ZLIB_FOUND)
|
||||
set(HAVE_ZLIB 1)
|
||||
# FindZLIB module define ZLIB_INCLUDE_DIRS variable
|
||||
# Set ZLIB_INCLUDE_DIRECTORIES for compatible
|
||||
set(ZLIB_INCLUDE_DIRECTORIES ${ZLIB_INCLUDE_DIRECTORIES} ${ZLIB_INCLUDE_DIRS})
|
||||
# Using imported target if exists
|
||||
if (TARGET ZLIB::ZLIB)
|
||||
set(ZLIB_LIBRARIES ZLIB::ZLIB)
|
||||
set(_protobuf_FIND_ZLIB "if(NOT ZLIB_FOUND)\n find_package(ZLIB)\nendif()")
|
||||
endif (TARGET ZLIB::ZLIB)
|
||||
else (ZLIB_FOUND)
|
||||
set(HAVE_ZLIB 0)
|
||||
# Explicitly set these to empty (override NOT_FOUND) so cmake doesn't
|
||||
# complain when we use them later.
|
||||
set(ZLIB_INCLUDE_DIRECTORIES)
|
||||
set(ZLIB_LIBRARIES)
|
||||
endif (ZLIB_FOUND)
|
||||
endif (protobuf_WITH_ZLIB)
|
||||
|
||||
if (HAVE_ZLIB)
|
||||
add_definitions(-DHAVE_ZLIB)
|
||||
endif (HAVE_ZLIB)
|
||||
|
||||
# We need to link with libatomic on systems that do not have builtin atomics, or
|
||||
# don't have builtin support for 8 byte atomics
|
||||
set(protobuf_LINK_LIBATOMIC false)
|
||||
if (NOT MSVC)
|
||||
include(CheckCXXSourceCompiles)
|
||||
set(OLD_CMAKE_REQUIRED_FLAGS ${CMAKE_REQUIRED_FLAGS})
|
||||
set(CMAKE_REQUIRED_FLAGS ${CMAKE_REQUIRED_FLAGS} -std=c++11)
|
||||
check_cxx_source_compiles("
|
||||
#include <atomic>
|
||||
int main() {
|
||||
return std::atomic<int64_t>{};
|
||||
}
|
||||
" protobuf_HAVE_BUILTIN_ATOMICS)
|
||||
if (NOT protobuf_HAVE_BUILTIN_ATOMICS)
|
||||
set(protobuf_LINK_LIBATOMIC true)
|
||||
endif (NOT protobuf_HAVE_BUILTIN_ATOMICS)
|
||||
set(CMAKE_REQUIRED_FLAGS ${OLD_CMAKE_REQUIRED_FLAGS})
|
||||
endif (NOT MSVC)
|
||||
|
||||
if (protobuf_BUILD_SHARED_LIBS)
|
||||
set(protobuf_SHARED_OR_STATIC "SHARED")
|
||||
else (protobuf_BUILD_SHARED_LIBS)
|
||||
set(protobuf_SHARED_OR_STATIC "STATIC")
|
||||
# The CMAKE_<LANG>_FLAGS(_<BUILD_TYPE>)? is meant to be user controlled.
|
||||
# Prior to CMake 3.15, the MSVC runtime library was pushed into the same flags
|
||||
# making programmatic control difficult. Prefer the functionality in newer
|
||||
# CMake versions when available.
|
||||
if(${CMAKE_VERSION} VERSION_GREATER 3.15 OR ${CMAKE_VERSION} VERSION_EQUAL 3.15)
|
||||
if (protobuf_MSVC_STATIC_RUNTIME)
|
||||
set(CMAKE_MSVC_RUNTIME_LIBRARY MultiThreaded$<$<CONFIG:Debug>:Debug>)
|
||||
else()
|
||||
set(CMAKE_MSVC_RUNTIME_LIBRARY MultiThreaded$<$<CONFIG:Debug>:Debug>DLL)
|
||||
endif()
|
||||
else()
|
||||
# In case we are building static libraries, link also the runtime library statically
|
||||
# so that MSVCR*.DLL is not required at runtime.
|
||||
# https://msdn.microsoft.com/en-us/library/2kzt1wy3.aspx
|
||||
# This is achieved by replacing msvc option /MD with /MT and /MDd with /MTd
|
||||
# http://www.cmake.org/Wiki/CMake_FAQ#How_can_I_build_my_MSVC_application_with_a_static_runtime.3F
|
||||
if (MSVC AND protobuf_MSVC_STATIC_RUNTIME)
|
||||
foreach(flag_var
|
||||
CMAKE_CXX_FLAGS CMAKE_CXX_FLAGS_DEBUG CMAKE_CXX_FLAGS_RELEASE
|
||||
CMAKE_CXX_FLAGS_MINSIZEREL CMAKE_CXX_FLAGS_RELWITHDEBINFO)
|
||||
if(${flag_var} MATCHES "/MD")
|
||||
string(REGEX REPLACE "/MD" "/MT" ${flag_var} "${${flag_var}}")
|
||||
endif(${flag_var} MATCHES "/MD")
|
||||
endforeach(flag_var)
|
||||
endif (MSVC AND protobuf_MSVC_STATIC_RUNTIME)
|
||||
endif()
|
||||
endif (protobuf_BUILD_SHARED_LIBS)
|
||||
|
||||
if (MSVC)
|
||||
if (CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
|
||||
# Build with multiple processes
|
||||
add_definitions(/MP)
|
||||
endif()
|
||||
# Set source file and execution character sets to UTF-8
|
||||
add_definitions(/utf-8)
|
||||
# MSVC warning suppressions
|
||||
add_definitions(
|
||||
/wd4065 # switch statement contains 'default' but no 'case' labels
|
||||
/wd4244 # 'conversion' conversion from 'type1' to 'type2', possible loss of data
|
||||
/wd4251 # 'identifier' : class 'type' needs to have dll-interface to be used by clients of class 'type2'
|
||||
/wd4267 # 'var' : conversion from 'size_t' to 'type', possible loss of data
|
||||
/wd4305 # 'identifier' : truncation from 'type1' to 'type2'
|
||||
/wd4307 # 'operator' : integral constant overflow
|
||||
/wd4309 # 'conversion' : truncation of constant value
|
||||
/wd4334 # 'operator' : result of 32-bit shift implicitly converted to 64 bits (was 64-bit shift intended?)
|
||||
/wd4355 # 'this' : used in base member initializer list
|
||||
/wd4506 # no definition for inline function 'function'
|
||||
/wd4800 # 'type' : forcing value to bool 'true' or 'false' (performance warning)
|
||||
/wd4996 # The compiler encountered a deprecated declaration.
|
||||
)
|
||||
# Allow big object
|
||||
add_definitions(/bigobj)
|
||||
string(REPLACE "/" "\\" PROTOBUF_SOURCE_WIN32_PATH ${protobuf_SOURCE_DIR})
|
||||
string(REPLACE "/" "\\" PROTOBUF_BINARY_WIN32_PATH ${protobuf_BINARY_DIR})
|
||||
string(REPLACE "." "," protobuf_RC_FILEVERSION "${protobuf_VERSION}")
|
||||
configure_file(${protobuf_SOURCE_DIR}/cmake/extract_includes.bat.in extract_includes.bat)
|
||||
|
||||
# Suppress linker warnings about files with no symbols defined.
|
||||
set(CMAKE_STATIC_LINKER_FLAGS "${CMAKE_STATIC_LINKER_FLAGS} /ignore:4221")
|
||||
|
||||
if (CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
|
||||
# Configure Resource Compiler
|
||||
enable_language(RC)
|
||||
# use English language (0x409) in resource compiler
|
||||
set(rc_flags "/l0x409")
|
||||
# fix rc.exe invocations because of usage of add_definitions()
|
||||
set(CMAKE_RC_COMPILE_OBJECT "<CMAKE_RC_COMPILER> ${rc_flags} <DEFINES> /fo<OBJECT> <SOURCE>")
|
||||
endif()
|
||||
|
||||
# Generate the version.rc file used elsewhere.
|
||||
configure_file(${protobuf_SOURCE_DIR}/cmake/version.rc.in ${CMAKE_CURRENT_BINARY_DIR}/version.rc @ONLY)
|
||||
set(protobuf_version_rc_file ${CMAKE_CURRENT_BINARY_DIR}/version.rc)
|
||||
|
||||
# Add the "lib" prefix for generated .lib outputs.
|
||||
set(LIB_PREFIX lib)
|
||||
else (MSVC)
|
||||
# No version.rc file.
|
||||
set(protobuf_version_rc_file)
|
||||
|
||||
# When building with "make", "lib" prefix will be added automatically by
|
||||
# the build tool.
|
||||
set(LIB_PREFIX)
|
||||
endif (MSVC)
|
||||
|
||||
include_directories(
|
||||
${ZLIB_INCLUDE_DIRECTORIES}
|
||||
${protobuf_BINARY_DIR}
|
||||
${protobuf_SOURCE_DIR}/src)
|
||||
|
||||
if (protobuf_UNICODE)
|
||||
add_definitions(-DUNICODE -D_UNICODE)
|
||||
endif (protobuf_UNICODE)
|
||||
|
||||
include(${protobuf_SOURCE_DIR}/cmake/libprotobuf-lite.cmake)
|
||||
include(${protobuf_SOURCE_DIR}/cmake/libprotobuf.cmake)
|
||||
if (protobuf_BUILD_LIBPROTOC)
|
||||
include(${protobuf_SOURCE_DIR}/cmake/libprotoc.cmake)
|
||||
endif (protobuf_BUILD_LIBPROTOC)
|
||||
if (protobuf_BUILD_PROTOC_BINARIES)
|
||||
include(${protobuf_SOURCE_DIR}/cmake/protoc.cmake)
|
||||
if (NOT DEFINED protobuf_PROTOC_EXE)
|
||||
set(protobuf_PROTOC_EXE protoc)
|
||||
endif (NOT DEFINED protobuf_PROTOC_EXE)
|
||||
endif (protobuf_BUILD_PROTOC_BINARIES)
|
||||
|
||||
# Ensure we have a protoc executable if we need one
|
||||
if (protobuf_BUILD_TESTS OR protobuf_BUILD_CONFORMANCE OR protobuf_BUILD_EXAMPLES)
|
||||
if (NOT DEFINED protobuf_PROTOC_EXE)
|
||||
find_program(protobuf_PROTOC_EXE protoc)
|
||||
if (NOT protobuf_PROTOC_EXE)
|
||||
message(FATAL "Build requires 'protoc' but binary not found and not building protoc.")
|
||||
endif ()
|
||||
endif ()
|
||||
if(protobuf_VERBOSE)
|
||||
message(STATUS "Using protoc : ${protobuf_PROTOC_EXE}")
|
||||
endif(protobuf_VERBOSE)
|
||||
endif ()
|
||||
|
||||
if (protobuf_BUILD_TESTS)
|
||||
enable_testing()
|
||||
include(${protobuf_SOURCE_DIR}/cmake/tests.cmake)
|
||||
endif (protobuf_BUILD_TESTS)
|
||||
|
||||
if (protobuf_BUILD_CONFORMANCE)
|
||||
include(${protobuf_SOURCE_DIR}/cmake/conformance.cmake)
|
||||
endif (protobuf_BUILD_CONFORMANCE)
|
||||
|
||||
if (protobuf_INSTALL)
|
||||
include(${protobuf_SOURCE_DIR}/cmake/install.cmake)
|
||||
endif (protobuf_INSTALL)
|
||||
|
||||
if (protobuf_BUILD_EXAMPLES)
|
||||
include(${protobuf_SOURCE_DIR}/cmake/examples.cmake)
|
||||
endif (protobuf_BUILD_EXAMPLES)
|
||||
|
||||
if(protobuf_VERBOSE)
|
||||
message(STATUS "Protocol Buffers Configuring done")
|
||||
endif(protobuf_VERBOSE)
|
||||
|
||||
@ -1,5 +1,4 @@
|
||||
Copyright 2008, Google Inc.
|
||||
All rights reserved.
|
||||
Copyright 2008 Google Inc. All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are
|
||||
@ -0,0 +1,9 @@
|
||||
cmake_minimum_required(VERSION 3.5)
|
||||
|
||||
message(WARNING "Calling of cmake with source directory set to \"cmake\" subdirectory of Protocol Buffers project is deprecated. Top-level directory of Protocol Buffers project should be used instead.")
|
||||
|
||||
project(protobuf C CXX)
|
||||
|
||||
set(protobuf_DEPRECATED_CMAKE_SUBDIRECTORY_USAGE TRUE)
|
||||
|
||||
include(../CMakeLists.txt)
|
||||
@ -0,0 +1,49 @@
|
||||
|
||||
add_custom_command(
|
||||
OUTPUT ${protobuf_SOURCE_DIR}/conformance/conformance.pb.cc
|
||||
DEPENDS ${protobuf_PROTOC_EXE} ${protobuf_SOURCE_DIR}/conformance/conformance.proto
|
||||
COMMAND ${protobuf_PROTOC_EXE} ${protobuf_SOURCE_DIR}/conformance/conformance.proto
|
||||
--proto_path=${protobuf_SOURCE_DIR}/conformance
|
||||
--cpp_out=${protobuf_SOURCE_DIR}/conformance
|
||||
)
|
||||
|
||||
add_custom_command(
|
||||
OUTPUT ${protobuf_SOURCE_DIR}/src/google/protobuf/test_messages_proto3.pb.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/test_messages_proto2.pb.cc
|
||||
DEPENDS ${protobuf_PROTOC_EXE} ${protobuf_SOURCE_DIR}/src/google/protobuf/test_messages_proto3.proto
|
||||
${protobuf_PROTOC_EXE} ${protobuf_SOURCE_DIR}/src/google/protobuf/test_messages_proto2.proto
|
||||
COMMAND ${protobuf_PROTOC_EXE} ${protobuf_SOURCE_DIR}/src/google/protobuf/test_messages_proto3.proto
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/test_messages_proto2.proto
|
||||
--proto_path=${protobuf_SOURCE_DIR}/src
|
||||
--cpp_out=${protobuf_SOURCE_DIR}/src
|
||||
)
|
||||
|
||||
add_executable(conformance_test_runner
|
||||
${protobuf_SOURCE_DIR}/conformance/binary_json_conformance_suite.cc
|
||||
${protobuf_SOURCE_DIR}/conformance/binary_json_conformance_suite.h
|
||||
${protobuf_SOURCE_DIR}/conformance/conformance.pb.cc
|
||||
${protobuf_SOURCE_DIR}/conformance/conformance_test.cc
|
||||
${protobuf_SOURCE_DIR}/conformance/conformance_test_runner.cc
|
||||
${protobuf_SOURCE_DIR}/conformance/third_party/jsoncpp/json.h
|
||||
${protobuf_SOURCE_DIR}/conformance/third_party/jsoncpp/jsoncpp.cpp
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/test_messages_proto2.pb.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/test_messages_proto3.pb.cc
|
||||
)
|
||||
|
||||
add_executable(conformance_cpp
|
||||
${protobuf_SOURCE_DIR}/conformance/conformance.pb.cc
|
||||
${protobuf_SOURCE_DIR}/conformance/conformance_cpp.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/test_messages_proto2.pb.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/test_messages_proto3.pb.cc
|
||||
)
|
||||
|
||||
target_include_directories(
|
||||
conformance_test_runner
|
||||
PUBLIC ${protobuf_SOURCE_DIR}/conformance)
|
||||
|
||||
target_include_directories(
|
||||
conformance_cpp
|
||||
PUBLIC ${protobuf_SOURCE_DIR}/conformance)
|
||||
|
||||
target_link_libraries(conformance_test_runner libprotobuf)
|
||||
target_link_libraries(conformance_cpp libprotobuf)
|
||||
@ -0,0 +1,57 @@
|
||||
if(protobuf_VERBOSE)
|
||||
message(STATUS "Protocol Buffers Examples Configuring...")
|
||||
endif()
|
||||
|
||||
get_filename_component(examples_dir "${protobuf_SOURCE_DIR}/examples" ABSOLUTE)
|
||||
|
||||
if(protobuf_VERBOSE)
|
||||
message(STATUS "Protocol Buffers Examples Configuring done")
|
||||
endif()
|
||||
include(ExternalProject)
|
||||
|
||||
# Internal utility function: Create a custom target representing a build of examples with custom options.
|
||||
function(add_examples_build NAME)
|
||||
|
||||
ExternalProject_Add(${NAME}
|
||||
PREFIX ${NAME}
|
||||
SOURCE_DIR "${examples_dir}"
|
||||
BINARY_DIR ${NAME}
|
||||
STAMP_DIR ${NAME}/logs
|
||||
INSTALL_COMMAND "" #Skip
|
||||
LOG_CONFIGURE 1
|
||||
CMAKE_CACHE_ARGS "-DCMAKE_BUILD_TYPE:STRING=${CMAKE_BUILD_TYPE}"
|
||||
"-Dprotobuf_VERBOSE:BOOL=${protobuf_VERBOSE}"
|
||||
${ARGN}
|
||||
)
|
||||
set_property(TARGET ${NAME} PROPERTY FOLDER "Examples")
|
||||
set_property(TARGET ${NAME} PROPERTY EXCLUDE_FROM_ALL TRUE)
|
||||
endfunction()
|
||||
|
||||
# Add examples as an external project.
|
||||
# sub_directory cannot be used because the find_package(protobuf) call would cause failures with redefined targets.
|
||||
add_examples_build(examples "-Dprotobuf_DIR:PATH=${CMAKE_BINARY_DIR}/${CMAKE_INSTALL_CMAKEDIR}")
|
||||
add_dependencies(examples libprotobuf protoc)
|
||||
|
||||
option(protobuf_BUILD_EXAMPLES_MULTITEST "Build Examples in multiple configurations. Useful for testing." OFF)
|
||||
mark_as_advanced(protobuf_BUILD_EXAMPLES_MULTITEST)
|
||||
if(protobuf_BUILD_EXAMPLES_MULTITEST)
|
||||
set_property(GLOBAL PROPERTY USE_FOLDERS ON)
|
||||
|
||||
#Build using the legacy compatibility module.
|
||||
add_examples_build(examples-legacy
|
||||
"-Dprotobuf_DIR:PATH=${CMAKE_BINARY_DIR}/${CMAKE_INSTALL_CMAKEDIR}"
|
||||
"-Dprotobuf_MODULE_COMPATIBLE:BOOL=TRUE"
|
||||
)
|
||||
add_dependencies(examples-legacy libprotobuf protoc)
|
||||
|
||||
#Build using the installed library.
|
||||
add_examples_build(examples-installed
|
||||
"-Dprotobuf_DIR:PATH=${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_CMAKEDIR}"
|
||||
)
|
||||
|
||||
#Build using the installed library in legacy compatibility mode.
|
||||
add_examples_build(examples-installed-legacy
|
||||
"-Dprotobuf_DIR:PATH=${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_CMAKEDIR}"
|
||||
"-Dprotobuf_MODULE_COMPATIBLE:BOOL=TRUE"
|
||||
)
|
||||
endif()
|
||||
@ -0,0 +1,144 @@
|
||||
mkdir include
|
||||
mkdir include\google
|
||||
mkdir include\google\protobuf
|
||||
mkdir include\google\protobuf\compiler
|
||||
mkdir include\google\protobuf\compiler\cpp
|
||||
mkdir include\google\protobuf\compiler\csharp
|
||||
mkdir include\google\protobuf\compiler\java
|
||||
mkdir include\google\protobuf\compiler\objectivec
|
||||
mkdir include\google\protobuf\compiler\php
|
||||
mkdir include\google\protobuf\compiler\python
|
||||
mkdir include\google\protobuf\compiler\ruby
|
||||
mkdir include\google\protobuf\io
|
||||
mkdir include\google\protobuf\stubs
|
||||
mkdir include\google\protobuf\util
|
||||
copy "${PROTOBUF_SOURCE_WIN32_PATH}\..\src\google\protobuf\any.h" include\google\protobuf\any.h
|
||||
copy "${PROTOBUF_SOURCE_WIN32_PATH}\..\src\google\protobuf\any.pb.h" include\google\protobuf\any.pb.h
|
||||
copy "${PROTOBUF_SOURCE_WIN32_PATH}\..\src\google\protobuf\api.pb.h" include\google\protobuf\api.pb.h
|
||||
copy "${PROTOBUF_SOURCE_WIN32_PATH}\..\src\google\protobuf\arena.h" include\google\protobuf\arena.h
|
||||
copy "${PROTOBUF_SOURCE_WIN32_PATH}\..\src\google\protobuf\arena_impl.h" include\google\protobuf\arena_impl.h
|
||||
copy "${PROTOBUF_SOURCE_WIN32_PATH}\..\src\google\protobuf\arenastring.h" include\google\protobuf\arenastring.h
|
||||
copy "${PROTOBUF_SOURCE_WIN32_PATH}\..\src\google\protobuf\arenaz_sampler.h" include\google\protobuf\arenaz_sampler.h
|
||||
copy "${PROTOBUF_SOURCE_WIN32_PATH}\..\src\google\protobuf\compiler\code_generator.h" include\google\protobuf\compiler\code_generator.h
|
||||
copy "${PROTOBUF_SOURCE_WIN32_PATH}\..\src\google\protobuf\compiler\command_line_interface.h" include\google\protobuf\compiler\command_line_interface.h
|
||||
copy "${PROTOBUF_SOURCE_WIN32_PATH}\..\src\google\protobuf\compiler\cpp\file.h" include\google\protobuf\compiler\cpp\file.h
|
||||
copy "${PROTOBUF_SOURCE_WIN32_PATH}\..\src\google\protobuf\compiler\cpp\cpp_generator.h" include\google\protobuf\compiler\cpp\cpp_generator.h
|
||||
copy "${PROTOBUF_SOURCE_WIN32_PATH}\..\src\google\protobuf\compiler\cpp\generator.h" include\google\protobuf\compiler\cpp\generator.h
|
||||
copy "${PROTOBUF_SOURCE_WIN32_PATH}\..\src\google\protobuf\compiler\cpp\helpers.h" include\google\protobuf\compiler\cpp\helpers.h
|
||||
copy "${PROTOBUF_SOURCE_WIN32_PATH}\..\src\google\protobuf\compiler\cpp\names.h" include\google\protobuf\compiler\cpp\names.h
|
||||
copy "${PROTOBUF_SOURCE_WIN32_PATH}\..\src\google\protobuf\compiler\csharp\csharp_doc_comment.h" include\google\protobuf\compiler\csharp\csharp_doc_comment.h
|
||||
copy "${PROTOBUF_SOURCE_WIN32_PATH}\..\src\google\protobuf\compiler\csharp\csharp_generator.h" include\google\protobuf\compiler\csharp\csharp_generator.h
|
||||
copy "${PROTOBUF_SOURCE_WIN32_PATH}\..\src\google\protobuf\compiler\csharp\csharp_names.h" include\google\protobuf\compiler\csharp\csharp_names.h
|
||||
copy "${PROTOBUF_SOURCE_WIN32_PATH}\..\src\google\protobuf\compiler\csharp\csharp_options.h" include\google\protobuf\compiler\csharp\csharp_options.h
|
||||
copy "${PROTOBUF_SOURCE_WIN32_PATH}\..\src\google\protobuf\compiler\importer.h" include\google\protobuf\compiler\importer.h
|
||||
copy "${PROTOBUF_SOURCE_WIN32_PATH}\..\src\google\protobuf\compiler\java\generator.h" include\google\protobuf\compiler\java\generator.h
|
||||
copy "${PROTOBUF_SOURCE_WIN32_PATH}\..\src\google\protobuf\compiler\java\java_generator.h" include\google\protobuf\compiler\java\java_generator.h
|
||||
copy "${PROTOBUF_SOURCE_WIN32_PATH}\..\src\google\protobuf\compiler\java\kotlin_generator.h" include\google\protobuf\compiler\java\kotlin_generator.h
|
||||
copy "${PROTOBUF_SOURCE_WIN32_PATH}\..\src\google\protobuf\compiler\java\names.h" include\google\protobuf\compiler\java\names.h
|
||||
copy "${PROTOBUF_SOURCE_WIN32_PATH}\..\src\google\protobuf\compiler\objectivec\objectivec_generator.h" include\google\protobuf\compiler\objectivec\objectivec_generator.h
|
||||
copy "${PROTOBUF_SOURCE_WIN32_PATH}\..\src\google\protobuf\compiler\objectivec\objectivec_helpers.h" include\google\protobuf\compiler\objectivec\objectivec_helpers.h
|
||||
copy "${PROTOBUF_SOURCE_WIN32_PATH}\..\src\google\protobuf\compiler\parser.h" include\google\protobuf\compiler\parser.h
|
||||
copy "${PROTOBUF_SOURCE_WIN32_PATH}\..\src\google\protobuf\compiler\php\php_generator.h" include\google\protobuf\compiler\php\php_generator.h
|
||||
copy "${PROTOBUF_SOURCE_WIN32_PATH}\..\src\google\protobuf\compiler\plugin.h" include\google\protobuf\compiler\plugin.h
|
||||
copy "${PROTOBUF_SOURCE_WIN32_PATH}\..\src\google\protobuf\compiler\plugin.pb.h" include\google\protobuf\compiler\plugin.pb.h
|
||||
copy "${PROTOBUF_SOURCE_WIN32_PATH}\..\src\google\protobuf\compiler\python\generator.h" include\google\protobuf\compiler\python\generator.h
|
||||
copy "${PROTOBUF_SOURCE_WIN32_PATH}\..\src\google\protobuf\compiler\python\pyi_generator.h" include\google\protobuf\compiler\python\pyi_generator.h
|
||||
copy "${PROTOBUF_SOURCE_WIN32_PATH}\..\src\google\protobuf\compiler\python\python_generator.h" include\google\protobuf\compiler\python\python_generator.h
|
||||
copy "${PROTOBUF_SOURCE_WIN32_PATH}\..\src\google\protobuf\compiler\ruby\ruby_generator.h" include\google\protobuf\compiler\ruby\ruby_generator.h
|
||||
copy "${PROTOBUF_SOURCE_WIN32_PATH}\..\src\google\protobuf\descriptor.h" include\google\protobuf\descriptor.h
|
||||
copy "${PROTOBUF_SOURCE_WIN32_PATH}\..\src\google\protobuf\descriptor.pb.h" include\google\protobuf\descriptor.pb.h
|
||||
copy "${PROTOBUF_SOURCE_WIN32_PATH}\..\src\google\protobuf\descriptor_database.h" include\google\protobuf\descriptor_database.h
|
||||
copy "${PROTOBUF_SOURCE_WIN32_PATH}\..\src\google\protobuf\duration.pb.h" include\google\protobuf\duration.pb.h
|
||||
copy "${PROTOBUF_SOURCE_WIN32_PATH}\..\src\google\protobuf\dynamic_message.h" include\google\protobuf\dynamic_message.h
|
||||
copy "${PROTOBUF_SOURCE_WIN32_PATH}\..\src\google\protobuf\empty.pb.h" include\google\protobuf\empty.pb.h
|
||||
copy "${PROTOBUF_SOURCE_WIN32_PATH}\..\src\google\protobuf\endian.h" include\google\protobuf\endian.h
|
||||
copy "${PROTOBUF_SOURCE_WIN32_PATH}\..\src\google\protobuf\explicitly_constructed.h" include\google\protobuf\explicitly_constructed.h
|
||||
copy "${PROTOBUF_SOURCE_WIN32_PATH}\..\src\google\protobuf\extension_set.h" include\google\protobuf\extension_set.h
|
||||
copy "${PROTOBUF_SOURCE_WIN32_PATH}\..\src\google\protobuf\extension_set_inl.h" include\google\protobuf\extension_set_inl.h
|
||||
copy "${PROTOBUF_SOURCE_WIN32_PATH}\..\src\google\protobuf\field_access_listener.h" include\google\protobuf\field_access_listener.h
|
||||
copy "${PROTOBUF_SOURCE_WIN32_PATH}\..\src\google\protobuf\field_mask.pb.h" include\google\protobuf\field_mask.pb.h
|
||||
copy "${PROTOBUF_SOURCE_WIN32_PATH}\..\src\google\protobuf\generated_enum_reflection.h" include\google\protobuf\generated_enum_reflection.h
|
||||
copy "${PROTOBUF_SOURCE_WIN32_PATH}\..\src\google\protobuf\generated_enum_util.h" include\google\protobuf\generated_enum_util.h
|
||||
copy "${PROTOBUF_SOURCE_WIN32_PATH}\..\src\google\protobuf\generated_message_bases.h" include\google\protobuf\generated_message_bases.h
|
||||
copy "${PROTOBUF_SOURCE_WIN32_PATH}\..\src\google\protobuf\generated_message_reflection.h" include\google\protobuf\generated_message_reflection.h
|
||||
copy "${PROTOBUF_SOURCE_WIN32_PATH}\..\src\google\protobuf\generated_message_tctable_decl.h" include\google\protobuf\generated_message_tctable_decl.h
|
||||
copy "${PROTOBUF_SOURCE_WIN32_PATH}\..\src\google\protobuf\generated_message_tctable_impl.h" include\google\protobuf\generated_message_tctable_impl.h
|
||||
copy "${PROTOBUF_SOURCE_WIN32_PATH}\..\src\google\protobuf\generated_message_util.h" include\google\protobuf\generated_message_util.h
|
||||
copy "${PROTOBUF_SOURCE_WIN32_PATH}\..\src\google\protobuf\has_bits.h" include\google\protobuf\has_bits.h
|
||||
copy "${PROTOBUF_SOURCE_WIN32_PATH}\..\src\google\protobuf\implicit_weak_message.h" include\google\protobuf\implicit_weak_message.h
|
||||
copy "${PROTOBUF_SOURCE_WIN32_PATH}\..\src\google\protobuf\inlined_string_field.h" include\google\protobuf\inlined_string_field.h
|
||||
copy "${PROTOBUF_SOURCE_WIN32_PATH}\..\src\google\protobuf\io\coded_stream.h" include\google\protobuf\io\coded_stream.h
|
||||
copy "${PROTOBUF_SOURCE_WIN32_PATH}\..\src\google\protobuf\io\gzip_stream.h" include\google\protobuf\io\gzip_stream.h
|
||||
copy "${PROTOBUF_SOURCE_WIN32_PATH}\..\src\google\protobuf\io\io_win32.h" include\google\protobuf\io\io_win32.h
|
||||
copy "${PROTOBUF_SOURCE_WIN32_PATH}\..\src\google\protobuf\io\printer.h" include\google\protobuf\io\printer.h
|
||||
copy "${PROTOBUF_SOURCE_WIN32_PATH}\..\src\google\protobuf\io\strtod.h" include\google\protobuf\io\strtod.h
|
||||
copy "${PROTOBUF_SOURCE_WIN32_PATH}\..\src\google\protobuf\io\tokenizer.h" include\google\protobuf\io\tokenizer.h
|
||||
copy "${PROTOBUF_SOURCE_WIN32_PATH}\..\src\google\protobuf\io\zero_copy_stream.h" include\google\protobuf\io\zero_copy_stream.h
|
||||
copy "${PROTOBUF_SOURCE_WIN32_PATH}\..\src\google\protobuf\io\zero_copy_stream_impl.h" include\google\protobuf\io\zero_copy_stream_impl.h
|
||||
copy "${PROTOBUF_SOURCE_WIN32_PATH}\..\src\google\protobuf\io\zero_copy_stream_impl_lite.h" include\google\protobuf\io\zero_copy_stream_impl_lite.h
|
||||
copy "${PROTOBUF_SOURCE_WIN32_PATH}\..\src\google\protobuf\map.h" include\google\protobuf\map.h
|
||||
copy "${PROTOBUF_SOURCE_WIN32_PATH}\..\src\google\protobuf\map_entry.h" include\google\protobuf\map_entry.h
|
||||
copy "${PROTOBUF_SOURCE_WIN32_PATH}\..\src\google\protobuf\map_entry_lite.h" include\google\protobuf\map_entry_lite.h
|
||||
copy "${PROTOBUF_SOURCE_WIN32_PATH}\..\src\google\protobuf\map_field.h" include\google\protobuf\map_field.h
|
||||
copy "${PROTOBUF_SOURCE_WIN32_PATH}\..\src\google\protobuf\map_field_inl.h" include\google\protobuf\map_field_inl.h
|
||||
copy "${PROTOBUF_SOURCE_WIN32_PATH}\..\src\google\protobuf\map_field_lite.h" include\google\protobuf\map_field_lite.h
|
||||
copy "${PROTOBUF_SOURCE_WIN32_PATH}\..\src\google\protobuf\map_type_handler.h" include\google\protobuf\map_type_handler.h
|
||||
copy "${PROTOBUF_SOURCE_WIN32_PATH}\..\src\google\protobuf\message.h" include\google\protobuf\message.h
|
||||
copy "${PROTOBUF_SOURCE_WIN32_PATH}\..\src\google\protobuf\message_lite.h" include\google\protobuf\message_lite.h
|
||||
copy "${PROTOBUF_SOURCE_WIN32_PATH}\..\src\google\protobuf\metadata.h" include\google\protobuf\metadata.h
|
||||
copy "${PROTOBUF_SOURCE_WIN32_PATH}\..\src\google\protobuf\metadata_lite.h" include\google\protobuf\metadata_lite.h
|
||||
copy "${PROTOBUF_SOURCE_WIN32_PATH}\..\src\google\protobuf\parse_context.h" include\google\protobuf\parse_context.h
|
||||
copy "${PROTOBUF_SOURCE_WIN32_PATH}\..\src\google\protobuf\port.h" include\google\protobuf\port.h
|
||||
copy "${PROTOBUF_SOURCE_WIN32_PATH}\..\src\google\protobuf\port_def.inc" include\google\protobuf\port_def.inc
|
||||
copy "${PROTOBUF_SOURCE_WIN32_PATH}\..\src\google\protobuf\port_undef.inc" include\google\protobuf\port_undef.inc
|
||||
copy "${PROTOBUF_SOURCE_WIN32_PATH}\..\src\google\protobuf\reflection.h" include\google\protobuf\reflection.h
|
||||
copy "${PROTOBUF_SOURCE_WIN32_PATH}\..\src\google\protobuf\reflection_ops.h" include\google\protobuf\reflection_ops.h
|
||||
copy "${PROTOBUF_SOURCE_WIN32_PATH}\..\src\google\protobuf\repeated_field.h" include\google\protobuf\repeated_field.h
|
||||
copy "${PROTOBUF_SOURCE_WIN32_PATH}\..\src\google\protobuf\repeated_ptr_field.h" include\google\protobuf\repeated_ptr_field.h
|
||||
copy "${PROTOBUF_SOURCE_WIN32_PATH}\..\src\google\protobuf\service.h" include\google\protobuf\service.h
|
||||
copy "${PROTOBUF_SOURCE_WIN32_PATH}\..\src\google\protobuf\source_context.pb.h" include\google\protobuf\source_context.pb.h
|
||||
copy "${PROTOBUF_SOURCE_WIN32_PATH}\..\src\google\protobuf\struct.pb.h" include\google\protobuf\struct.pb.h
|
||||
copy "${PROTOBUF_SOURCE_WIN32_PATH}\..\src\google\protobuf\stubs\bytestream.h" include\google\protobuf\stubs\bytestream.h
|
||||
copy "${PROTOBUF_SOURCE_WIN32_PATH}\..\src\google\protobuf\stubs\callback.h" include\google\protobuf\stubs\callback.h
|
||||
copy "${PROTOBUF_SOURCE_WIN32_PATH}\..\src\google\protobuf\stubs\casts.h" include\google\protobuf\stubs\casts.h
|
||||
copy "${PROTOBUF_SOURCE_WIN32_PATH}\..\src\google\protobuf\stubs\common.h" include\google\protobuf\stubs\common.h
|
||||
copy "${PROTOBUF_SOURCE_WIN32_PATH}\..\src\google\protobuf\stubs\hash.h" include\google\protobuf\stubs\hash.h
|
||||
copy "${PROTOBUF_SOURCE_WIN32_PATH}\..\src\google\protobuf\stubs\logging.h" include\google\protobuf\stubs\logging.h
|
||||
copy "${PROTOBUF_SOURCE_WIN32_PATH}\..\src\google\protobuf\stubs\macros.h" include\google\protobuf\stubs\macros.h
|
||||
copy "${PROTOBUF_SOURCE_WIN32_PATH}\..\src\google\protobuf\stubs\map_util.h" include\google\protobuf\stubs\map_util.h
|
||||
copy "${PROTOBUF_SOURCE_WIN32_PATH}\..\src\google\protobuf\stubs\mutex.h" include\google\protobuf\stubs\mutex.h
|
||||
copy "${PROTOBUF_SOURCE_WIN32_PATH}\..\src\google\protobuf\stubs\once.h" include\google\protobuf\stubs\once.h
|
||||
copy "${PROTOBUF_SOURCE_WIN32_PATH}\..\src\google\protobuf\stubs\platform_macros.h" include\google\protobuf\stubs\platform_macros.h
|
||||
copy "${PROTOBUF_SOURCE_WIN32_PATH}\..\src\google\protobuf\stubs\port.h" include\google\protobuf\stubs\port.h
|
||||
copy "${PROTOBUF_SOURCE_WIN32_PATH}\..\src\google\protobuf\stubs\status.h" include\google\protobuf\stubs\status.h
|
||||
copy "${PROTOBUF_SOURCE_WIN32_PATH}\..\src\google\protobuf\stubs\stl_util.h" include\google\protobuf\stubs\stl_util.h
|
||||
copy "${PROTOBUF_SOURCE_WIN32_PATH}\..\src\google\protobuf\stubs\stringpiece.h" include\google\protobuf\stubs\stringpiece.h
|
||||
copy "${PROTOBUF_SOURCE_WIN32_PATH}\..\src\google\protobuf\stubs\strutil.h" include\google\protobuf\stubs\strutil.h
|
||||
copy "${PROTOBUF_SOURCE_WIN32_PATH}\..\src\google\protobuf\stubs\template_util.h" include\google\protobuf\stubs\template_util.h
|
||||
copy "${PROTOBUF_SOURCE_WIN32_PATH}\..\src\google\protobuf\text_format.h" include\google\protobuf\text_format.h
|
||||
copy "${PROTOBUF_SOURCE_WIN32_PATH}\..\src\google\protobuf\timestamp.pb.h" include\google\protobuf\timestamp.pb.h
|
||||
copy "${PROTOBUF_SOURCE_WIN32_PATH}\..\src\google\protobuf\type.pb.h" include\google\protobuf\type.pb.h
|
||||
copy "${PROTOBUF_SOURCE_WIN32_PATH}\..\src\google\protobuf\unknown_field_set.h" include\google\protobuf\unknown_field_set.h
|
||||
copy "${PROTOBUF_SOURCE_WIN32_PATH}\..\src\google\protobuf\util\delimited_message_util.h" include\google\protobuf\util\delimited_message_util.h
|
||||
copy "${PROTOBUF_SOURCE_WIN32_PATH}\..\src\google\protobuf\util\field_comparator.h" include\google\protobuf\util\field_comparator.h
|
||||
copy "${PROTOBUF_SOURCE_WIN32_PATH}\..\src\google\protobuf\util\field_mask_util.h" include\google\protobuf\util\field_mask_util.h
|
||||
copy "${PROTOBUF_SOURCE_WIN32_PATH}\..\src\google\protobuf\util\json_util.h" include\google\protobuf\util\json_util.h
|
||||
copy "${PROTOBUF_SOURCE_WIN32_PATH}\..\src\google\protobuf\util\message_differencer.h" include\google\protobuf\util\message_differencer.h
|
||||
copy "${PROTOBUF_SOURCE_WIN32_PATH}\..\src\google\protobuf\util\time_util.h" include\google\protobuf\util\time_util.h
|
||||
copy "${PROTOBUF_SOURCE_WIN32_PATH}\..\src\google\protobuf\util\type_resolver.h" include\google\protobuf\util\type_resolver.h
|
||||
copy "${PROTOBUF_SOURCE_WIN32_PATH}\..\src\google\protobuf\util\type_resolver_util.h" include\google\protobuf\util\type_resolver_util.h
|
||||
copy "${PROTOBUF_SOURCE_WIN32_PATH}\..\src\google\protobuf\wire_format.h" include\google\protobuf\wire_format.h
|
||||
copy "${PROTOBUF_SOURCE_WIN32_PATH}\..\src\google\protobuf\wire_format_lite.h" include\google\protobuf\wire_format_lite.h
|
||||
copy "${PROTOBUF_SOURCE_WIN32_PATH}\..\src\google\protobuf\wrappers.pb.h" include\google\protobuf\wrappers.pb.h
|
||||
copy "${PROTOBUF_SOURCE_WIN32_PATH}\..\src\google\protobuf\any.proto" include\google\protobuf\any.proto
|
||||
copy "${PROTOBUF_SOURCE_WIN32_PATH}\..\src\google\protobuf\api.proto" include\google\protobuf\api.proto
|
||||
copy "${PROTOBUF_SOURCE_WIN32_PATH}\..\src\google\protobuf\compiler\plugin.proto" include\google\protobuf\compiler\plugin.proto
|
||||
copy "${PROTOBUF_SOURCE_WIN32_PATH}\..\src\google\protobuf\descriptor.proto" include\google\protobuf\descriptor.proto
|
||||
copy "${PROTOBUF_SOURCE_WIN32_PATH}\..\src\google\protobuf\duration.proto" include\google\protobuf\duration.proto
|
||||
copy "${PROTOBUF_SOURCE_WIN32_PATH}\..\src\google\protobuf\empty.proto" include\google\protobuf\empty.proto
|
||||
copy "${PROTOBUF_SOURCE_WIN32_PATH}\..\src\google\protobuf\field_mask.proto" include\google\protobuf\field_mask.proto
|
||||
copy "${PROTOBUF_SOURCE_WIN32_PATH}\..\src\google\protobuf\source_context.proto" include\google\protobuf\source_context.proto
|
||||
copy "${PROTOBUF_SOURCE_WIN32_PATH}\..\src\google\protobuf\struct.proto" include\google\protobuf\struct.proto
|
||||
copy "${PROTOBUF_SOURCE_WIN32_PATH}\..\src\google\protobuf\timestamp.proto" include\google\protobuf\timestamp.proto
|
||||
copy "${PROTOBUF_SOURCE_WIN32_PATH}\..\src\google\protobuf\type.proto" include\google\protobuf\type.proto
|
||||
copy "${PROTOBUF_SOURCE_WIN32_PATH}\..\src\google\protobuf\wrappers.proto" include\google\protobuf\wrappers.proto
|
||||
@ -0,0 +1,156 @@
|
||||
include(GNUInstallDirs)
|
||||
|
||||
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/cmake/protobuf.pc.cmake
|
||||
${CMAKE_CURRENT_BINARY_DIR}/protobuf.pc @ONLY)
|
||||
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/cmake/protobuf-lite.pc.cmake
|
||||
${CMAKE_CURRENT_BINARY_DIR}/protobuf-lite.pc @ONLY)
|
||||
|
||||
set(_protobuf_libraries libprotobuf-lite libprotobuf)
|
||||
if (protobuf_BUILD_LIBPROTOC)
|
||||
list(APPEND _protobuf_libraries libprotoc)
|
||||
endif (protobuf_BUILD_LIBPROTOC)
|
||||
|
||||
foreach(_library ${_protobuf_libraries})
|
||||
set_property(TARGET ${_library}
|
||||
PROPERTY INTERFACE_INCLUDE_DIRECTORIES
|
||||
$<BUILD_INTERFACE:${protobuf_SOURCE_DIR}/src>
|
||||
$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>)
|
||||
if (UNIX AND NOT APPLE)
|
||||
set_property(TARGET ${_library}
|
||||
PROPERTY INSTALL_RPATH "$ORIGIN")
|
||||
elseif (APPLE)
|
||||
set_property(TARGET ${_library}
|
||||
PROPERTY INSTALL_RPATH "@loader_path")
|
||||
endif()
|
||||
install(TARGETS ${_library} EXPORT protobuf-targets
|
||||
RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR} COMPONENT ${_library}
|
||||
LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR} COMPONENT ${_library}
|
||||
ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR} COMPONENT ${_library})
|
||||
endforeach()
|
||||
|
||||
if (protobuf_BUILD_PROTOC_BINARIES)
|
||||
install(TARGETS protoc EXPORT protobuf-targets
|
||||
RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR} COMPONENT protoc
|
||||
BUNDLE DESTINATION ${CMAKE_INSTALL_BINDIR} COMPONENT protoc)
|
||||
if (UNIX AND NOT APPLE)
|
||||
set_property(TARGET protoc
|
||||
PROPERTY INSTALL_RPATH "$ORIGIN/../${CMAKE_INSTALL_LIBDIR}")
|
||||
elseif (APPLE)
|
||||
set_property(TARGET protoc
|
||||
PROPERTY INSTALL_RPATH "@loader_path/../lib")
|
||||
endif()
|
||||
endif (protobuf_BUILD_PROTOC_BINARIES)
|
||||
|
||||
install(FILES ${CMAKE_CURRENT_BINARY_DIR}/protobuf.pc ${CMAKE_CURRENT_BINARY_DIR}/protobuf-lite.pc DESTINATION "${CMAKE_INSTALL_LIBDIR}/pkgconfig")
|
||||
|
||||
file(STRINGS ${protobuf_SOURCE_DIR}/cmake/extract_includes.bat.in _extract_strings
|
||||
REGEX "^copy")
|
||||
foreach(_extract_string ${_extract_strings})
|
||||
string(REGEX REPLACE "^.* .+ include\\\\(.+)$" "\\1"
|
||||
_header ${_extract_string})
|
||||
string(REPLACE "\\" "/" _header ${_header})
|
||||
get_filename_component(_extract_from "${protobuf_SOURCE_DIR}/src/${_header}" ABSOLUTE)
|
||||
get_filename_component(_extract_name ${_header} NAME)
|
||||
get_filename_component(_extract_to "${CMAKE_INSTALL_INCLUDEDIR}/${_header}" DIRECTORY)
|
||||
if(EXISTS "${_extract_from}")
|
||||
install(FILES "${_extract_from}"
|
||||
DESTINATION "${_extract_to}"
|
||||
COMPONENT protobuf-headers
|
||||
RENAME "${_extract_name}")
|
||||
else()
|
||||
message(AUTHOR_WARNING "The file \"${_extract_from}\" is listed in "
|
||||
"\"${protobuf_SOURCE_DIR}/cmake/extract_includes.bat.in\" "
|
||||
"but there not exists. The file will not be installed.")
|
||||
endif()
|
||||
endforeach()
|
||||
|
||||
# Internal function for parsing auto tools scripts
|
||||
function(_protobuf_auto_list FILE_NAME VARIABLE)
|
||||
file(STRINGS ${FILE_NAME} _strings)
|
||||
set(_list)
|
||||
foreach(_string ${_strings})
|
||||
set(_found)
|
||||
string(REGEX MATCH "^[ \t]*${VARIABLE}[ \t]*=[ \t]*" _found "${_string}")
|
||||
if(_found)
|
||||
string(LENGTH "${_found}" _length)
|
||||
string(SUBSTRING "${_string}" ${_length} -1 _draft_list)
|
||||
foreach(_item ${_draft_list})
|
||||
string(STRIP "${_item}" _item)
|
||||
list(APPEND _list "${_item}")
|
||||
endforeach()
|
||||
endif()
|
||||
endforeach()
|
||||
set(${VARIABLE} ${_list} PARENT_SCOPE)
|
||||
endfunction()
|
||||
|
||||
# Install well-known type proto files
|
||||
_protobuf_auto_list("${protobuf_SOURCE_DIR}/src/Makefile.am" nobase_dist_proto_DATA)
|
||||
foreach(_file ${nobase_dist_proto_DATA})
|
||||
get_filename_component(_file_from "${protobuf_SOURCE_DIR}/src/${_file}" ABSOLUTE)
|
||||
get_filename_component(_file_name ${_file} NAME)
|
||||
get_filename_component(_dir ${_file} DIRECTORY)
|
||||
if(EXISTS "${_file_from}")
|
||||
install(FILES "${_file_from}"
|
||||
DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}/${_dir}"
|
||||
COMPONENT protobuf-protos
|
||||
RENAME "${_file_name}")
|
||||
else()
|
||||
message(AUTHOR_WARNING "The file \"${_file_from}\" is listed in "
|
||||
"\"${protobuf_SOURCE_DIR}/src/Makefile.am\" as nobase_dist_proto_DATA "
|
||||
"but there not exists. The file will not be installed.")
|
||||
endif()
|
||||
endforeach()
|
||||
|
||||
# Install configuration
|
||||
set(_cmakedir_desc "Directory relative to CMAKE_INSTALL to install the cmake configuration files")
|
||||
set(_exampledir_desc "Directory relative to CMAKE_INSTALL_DATA to install examples")
|
||||
if(NOT MSVC)
|
||||
set(CMAKE_INSTALL_CMAKEDIR "${CMAKE_INSTALL_LIBDIR}/cmake/protobuf" CACHE STRING "${_cmakedir_desc}")
|
||||
set(CMAKE_INSTALL_EXAMPLEDIR "${CMAKE_INSTALL_DATADIR}/protobuf/examples" CACHE STRING "${_exampledir_desc}")
|
||||
else()
|
||||
set(CMAKE_INSTALL_CMAKEDIR "cmake" CACHE STRING "${_cmakedir_desc}")
|
||||
set(CMAKE_INSTALL_EXAMPLEDIR "examples" CACHE STRING "${_exampledir_desc}")
|
||||
endif()
|
||||
mark_as_advanced(CMAKE_INSTALL_CMAKEDIR)
|
||||
mark_as_advanced(CMAKE_INSTALL_EXAMPLEDIR)
|
||||
|
||||
configure_file(${protobuf_SOURCE_DIR}/cmake/protobuf-config.cmake.in
|
||||
${CMAKE_INSTALL_CMAKEDIR}/protobuf-config.cmake @ONLY)
|
||||
configure_file(${protobuf_SOURCE_DIR}/cmake/protobuf-config-version.cmake.in
|
||||
${CMAKE_INSTALL_CMAKEDIR}/protobuf-config-version.cmake @ONLY)
|
||||
configure_file(${protobuf_SOURCE_DIR}/cmake/protobuf-module.cmake.in
|
||||
${CMAKE_INSTALL_CMAKEDIR}/protobuf-module.cmake @ONLY)
|
||||
configure_file(${protobuf_SOURCE_DIR}/cmake/protobuf-options.cmake
|
||||
${CMAKE_INSTALL_CMAKEDIR}/protobuf-options.cmake @ONLY)
|
||||
|
||||
# Allows the build directory to be used as a find directory.
|
||||
|
||||
if (protobuf_BUILD_PROTOC_BINARIES)
|
||||
export(TARGETS libprotobuf-lite libprotobuf libprotoc protoc
|
||||
NAMESPACE protobuf::
|
||||
FILE ${CMAKE_INSTALL_CMAKEDIR}/protobuf-targets.cmake
|
||||
)
|
||||
else (protobuf_BUILD_PROTOC_BINARIES)
|
||||
export(TARGETS libprotobuf-lite libprotobuf
|
||||
NAMESPACE protobuf::
|
||||
FILE ${CMAKE_INSTALL_CMAKEDIR}/protobuf-targets.cmake
|
||||
)
|
||||
endif (protobuf_BUILD_PROTOC_BINARIES)
|
||||
|
||||
install(EXPORT protobuf-targets
|
||||
DESTINATION "${CMAKE_INSTALL_CMAKEDIR}"
|
||||
NAMESPACE protobuf::
|
||||
COMPONENT protobuf-export)
|
||||
|
||||
install(DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_INSTALL_CMAKEDIR}/
|
||||
DESTINATION "${CMAKE_INSTALL_CMAKEDIR}"
|
||||
COMPONENT protobuf-export
|
||||
PATTERN protobuf-targets.cmake EXCLUDE
|
||||
)
|
||||
|
||||
option(protobuf_INSTALL_EXAMPLES "Install the examples folder" OFF)
|
||||
if(protobuf_INSTALL_EXAMPLES)
|
||||
install(DIRECTORY examples/
|
||||
DESTINATION "${CMAKE_INSTALL_EXAMPLEDIR}"
|
||||
COMPONENT protobuf-examples)
|
||||
endif()
|
||||
@ -0,0 +1,118 @@
|
||||
set(libprotobuf_lite_files
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/any_lite.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/arena.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/arenastring.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/arenaz_sampler.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/extension_set.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/generated_enum_util.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/generated_message_tctable_lite.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/generated_message_util.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/implicit_weak_message.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/inlined_string_field.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/io/coded_stream.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/io/io_win32.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/io/strtod.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/io/zero_copy_stream.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/io/zero_copy_stream_impl.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/io/zero_copy_stream_impl_lite.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/map.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/message_lite.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/parse_context.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/repeated_field.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/repeated_ptr_field.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/stubs/bytestream.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/stubs/common.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/stubs/int128.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/stubs/status.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/stubs/statusor.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/stubs/stringpiece.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/stubs/stringprintf.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/stubs/structurally_valid.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/stubs/strutil.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/stubs/time.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/wire_format_lite.cc
|
||||
)
|
||||
|
||||
set(libprotobuf_lite_includes
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/any.h
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/arena.h
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/arena_impl.h
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/arenastring.h
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/arenaz_sampler.h
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/endian.h
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/explicitly_constructed.h
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/extension_set.h
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/extension_set_inl.h
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/generated_enum_util.h
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/generated_message_tctable_decl.h
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/generated_message_tctable_impl.h
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/generated_message_util.h
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/has_bits.h
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/implicit_weak_message.h
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/inlined_string_field.h
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/io/coded_stream.h
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/io/io_win32.h
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/io/strtod.h
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/io/zero_copy_stream.h
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/io/zero_copy_stream_impl.h
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/io/zero_copy_stream_impl_lite.h
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/map.h
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/map_entry_lite.h
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/map_field_lite.h
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/map_type_handler.h
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/message_lite.h
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/metadata_lite.h
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/parse_context.h
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/port.h
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/repeated_field.h
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/repeated_ptr_field.h
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/stubs/bytestream.h
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/stubs/callback.h
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/stubs/casts.h
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/stubs/common.h
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/stubs/hash.h
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/stubs/logging.h
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/stubs/macros.h
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/stubs/map_util.h
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/stubs/mutex.h
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/stubs/once.h
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/stubs/platform_macros.h
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/stubs/port.h
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/stubs/status.h
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/stubs/stl_util.h
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/stubs/stringpiece.h
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/stubs/strutil.h
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/stubs/template_util.h
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/wire_format_lite.h
|
||||
)
|
||||
|
||||
add_library(libprotobuf-lite ${protobuf_SHARED_OR_STATIC}
|
||||
${libprotobuf_lite_files} ${libprotobuf_lite_includes} ${protobuf_version_rc_file})
|
||||
if(protobuf_HAVE_LD_VERSION_SCRIPT)
|
||||
if(${CMAKE_VERSION} VERSION_GREATER 3.13 OR ${CMAKE_VERSION} VERSION_EQUAL 3.13)
|
||||
target_link_options(libprotobuf-lite PRIVATE -Wl,--version-script=${protobuf_SOURCE_DIR}/src/libprotobuf-lite.map)
|
||||
elseif(protobuf_BUILD_SHARED_LIBS)
|
||||
target_link_libraries(libprotobuf-lite PRIVATE -Wl,--version-script=${protobuf_SOURCE_DIR}/src/libprotobuf-lite.map)
|
||||
endif()
|
||||
set_target_properties(libprotobuf-lite PROPERTIES
|
||||
LINK_DEPENDS ${protobuf_SOURCE_DIR}/src/libprotobuf-lite.map)
|
||||
endif()
|
||||
target_link_libraries(libprotobuf-lite PRIVATE ${CMAKE_THREAD_LIBS_INIT})
|
||||
if(protobuf_LINK_LIBATOMIC)
|
||||
target_link_libraries(libprotobuf-lite PRIVATE atomic)
|
||||
endif()
|
||||
if(${CMAKE_SYSTEM_NAME} STREQUAL "Android")
|
||||
target_link_libraries(libprotobuf-lite PRIVATE log)
|
||||
endif()
|
||||
target_include_directories(libprotobuf-lite PUBLIC ${protobuf_SOURCE_DIR}/src)
|
||||
if(protobuf_BUILD_SHARED_LIBS)
|
||||
target_compile_definitions(libprotobuf-lite
|
||||
PUBLIC PROTOBUF_USE_DLLS
|
||||
PRIVATE LIBPROTOBUF_EXPORTS)
|
||||
endif()
|
||||
set_target_properties(libprotobuf-lite PROPERTIES
|
||||
VERSION ${protobuf_VERSION}
|
||||
SOVERSION 32
|
||||
OUTPUT_NAME ${LIB_PREFIX}protobuf-lite
|
||||
DEBUG_POSTFIX "${protobuf_DEBUG_POSTFIX}")
|
||||
add_library(protobuf::libprotobuf-lite ALIAS libprotobuf-lite)
|
||||
@ -0,0 +1,134 @@
|
||||
set(libprotobuf_files
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/any.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/any.pb.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/api.pb.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/compiler/importer.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/compiler/parser.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/descriptor.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/descriptor.pb.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/descriptor_database.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/duration.pb.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/dynamic_message.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/empty.pb.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/extension_set_heavy.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/field_mask.pb.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/generated_message_bases.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/generated_message_reflection.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/generated_message_tctable_full.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/io/gzip_stream.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/io/printer.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/io/tokenizer.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/map_field.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/message.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/reflection_ops.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/service.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/source_context.pb.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/struct.pb.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/stubs/substitute.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/text_format.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/timestamp.pb.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/type.pb.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/unknown_field_set.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/util/delimited_message_util.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/util/field_comparator.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/util/field_mask_util.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/util/internal/datapiece.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/util/internal/default_value_objectwriter.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/util/internal/error_listener.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/util/internal/field_mask_utility.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/util/internal/json_escaping.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/util/internal/json_objectwriter.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/util/internal/json_stream_parser.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/util/internal/object_writer.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/util/internal/proto_writer.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/util/internal/protostream_objectsource.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/util/internal/protostream_objectwriter.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/util/internal/type_info.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/util/internal/utility.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/util/json_util.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/util/message_differencer.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/util/time_util.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/util/type_resolver_util.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/wire_format.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/wrappers.pb.cc
|
||||
)
|
||||
|
||||
set(libprotobuf_includes
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/any.pb.h
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/api.pb.h
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/compiler/importer.h
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/compiler/parser.h
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/descriptor.h
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/descriptor.pb.h
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/descriptor_database.h
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/duration.pb.h
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/dynamic_message.h
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/empty.pb.h
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/field_access_listener.h
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/field_mask.pb.h
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/generated_enum_reflection.h
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/generated_message_bases.h
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/generated_message_reflection.h
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/io/gzip_stream.h
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/io/printer.h
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/io/tokenizer.h
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/map_entry.h
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/map_field.h
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/map_field_inl.h
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/message.h
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/metadata.h
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/reflection.h
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/reflection_internal.h
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/reflection_ops.h
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/service.h
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/source_context.pb.h
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/struct.pb.h
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/text_format.h
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/timestamp.pb.h
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/type.pb.h
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/unknown_field_set.h
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/util/delimited_message_util.h
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/util/field_comparator.h
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/util/field_mask_util.h
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/util/json_util.h
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/util/message_differencer.h
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/util/time_util.h
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/util/type_resolver.h
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/util/type_resolver_util.h
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/wire_format.h
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/wrappers.pb.h
|
||||
)
|
||||
|
||||
add_library(libprotobuf ${protobuf_SHARED_OR_STATIC}
|
||||
${libprotobuf_lite_files} ${libprotobuf_files} ${libprotobuf_includes} ${protobuf_version_rc_file})
|
||||
if(protobuf_HAVE_LD_VERSION_SCRIPT)
|
||||
if(${CMAKE_VERSION} VERSION_GREATER 3.13 OR ${CMAKE_VERSION} VERSION_EQUAL 3.13)
|
||||
target_link_options(libprotobuf PRIVATE -Wl,--version-script=${protobuf_SOURCE_DIR}/src/libprotobuf.map)
|
||||
elseif(protobuf_BUILD_SHARED_LIBS)
|
||||
target_link_libraries(libprotobuf PRIVATE -Wl,--version-script=${protobuf_SOURCE_DIR}/src/libprotobuf.map)
|
||||
endif()
|
||||
set_target_properties(libprotobuf PROPERTIES
|
||||
LINK_DEPENDS ${protobuf_SOURCE_DIR}/src/libprotobuf.map)
|
||||
endif()
|
||||
target_link_libraries(libprotobuf PRIVATE ${CMAKE_THREAD_LIBS_INIT})
|
||||
if(protobuf_WITH_ZLIB)
|
||||
target_link_libraries(libprotobuf PRIVATE ${ZLIB_LIBRARIES})
|
||||
endif()
|
||||
if(protobuf_LINK_LIBATOMIC)
|
||||
target_link_libraries(libprotobuf PRIVATE atomic)
|
||||
endif()
|
||||
if(${CMAKE_SYSTEM_NAME} STREQUAL "Android")
|
||||
target_link_libraries(libprotobuf PRIVATE log)
|
||||
endif()
|
||||
target_include_directories(libprotobuf PUBLIC ${protobuf_SOURCE_DIR}/src)
|
||||
if(protobuf_BUILD_SHARED_LIBS)
|
||||
target_compile_definitions(libprotobuf
|
||||
PUBLIC PROTOBUF_USE_DLLS
|
||||
PRIVATE LIBPROTOBUF_EXPORTS)
|
||||
endif()
|
||||
set_target_properties(libprotobuf PROPERTIES
|
||||
VERSION ${protobuf_VERSION}
|
||||
SOVERSION 32
|
||||
OUTPUT_NAME ${LIB_PREFIX}protobuf
|
||||
DEBUG_POSTFIX "${protobuf_DEBUG_POSTFIX}")
|
||||
add_library(protobuf::libprotobuf ALIAS libprotobuf)
|
||||
@ -0,0 +1,136 @@
|
||||
set(libprotoc_files
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/compiler/code_generator.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/compiler/command_line_interface.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/compiler/cpp/enum.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/compiler/cpp/enum_field.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/compiler/cpp/extension.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/compiler/cpp/field.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/compiler/cpp/file.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/compiler/cpp/generator.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/compiler/cpp/helpers.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/compiler/cpp/map_field.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/compiler/cpp/message.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/compiler/cpp/message_field.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/compiler/cpp/padding_optimizer.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/compiler/cpp/parse_function_generator.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/compiler/cpp/primitive_field.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/compiler/cpp/service.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/compiler/cpp/string_field.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/compiler/csharp/csharp_doc_comment.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/compiler/csharp/csharp_enum.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/compiler/csharp/csharp_enum_field.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/compiler/csharp/csharp_field_base.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/compiler/csharp/csharp_generator.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/compiler/csharp/csharp_helpers.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/compiler/csharp/csharp_map_field.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/compiler/csharp/csharp_message.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/compiler/csharp/csharp_message_field.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/compiler/csharp/csharp_primitive_field.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/compiler/csharp/csharp_reflection_class.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/compiler/csharp/csharp_repeated_enum_field.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/compiler/csharp/csharp_repeated_message_field.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/compiler/csharp/csharp_repeated_primitive_field.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/compiler/csharp/csharp_source_generator_base.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/compiler/csharp/csharp_wrapper_field.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/compiler/java/context.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/compiler/java/doc_comment.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/compiler/java/enum.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/compiler/java/enum_field.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/compiler/java/enum_field_lite.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/compiler/java/enum_lite.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/compiler/java/extension.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/compiler/java/extension_lite.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/compiler/java/field.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/compiler/java/file.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/compiler/java/generator.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/compiler/java/generator_factory.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/compiler/java/helpers.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/compiler/java/kotlin_generator.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/compiler/java/map_field.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/compiler/java/map_field_lite.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/compiler/java/message.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/compiler/java/message_builder.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/compiler/java/message_builder_lite.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/compiler/java/message_field.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/compiler/java/message_field_lite.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/compiler/java/message_lite.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/compiler/java/name_resolver.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/compiler/java/primitive_field.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/compiler/java/primitive_field_lite.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/compiler/java/service.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/compiler/java/shared_code_generator.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/compiler/java/string_field.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/compiler/java/string_field_lite.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/compiler/objectivec/objectivec_enum.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/compiler/objectivec/objectivec_enum_field.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/compiler/objectivec/objectivec_extension.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/compiler/objectivec/objectivec_field.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/compiler/objectivec/objectivec_file.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/compiler/objectivec/objectivec_generator.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/compiler/objectivec/objectivec_helpers.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/compiler/objectivec/objectivec_map_field.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/compiler/objectivec/objectivec_message.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/compiler/objectivec/objectivec_message_field.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/compiler/objectivec/objectivec_oneof.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/compiler/objectivec/objectivec_primitive_field.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/compiler/php/php_generator.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/compiler/plugin.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/compiler/plugin.pb.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/compiler/python/generator.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/compiler/python/helpers.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/compiler/python/pyi_generator.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/compiler/ruby/ruby_generator.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/compiler/subprocess.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/compiler/zip_writer.cc
|
||||
)
|
||||
|
||||
set(libprotoc_headers
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/compiler/code_generator.h
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/compiler/command_line_interface.h
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/compiler/cpp/cpp_generator.h
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/compiler/cpp/file.h
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/compiler/cpp/generator.h
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/compiler/cpp/helpers.h
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/compiler/cpp/names.h
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/compiler/csharp/csharp_doc_comment.h
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/compiler/csharp/csharp_generator.h
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/compiler/csharp/csharp_names.h
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/compiler/csharp/csharp_options.h
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/compiler/java/generator.h
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/compiler/java/java_generator.h
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/compiler/java/kotlin_generator.h
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/compiler/java/names.h
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/compiler/objectivec/objectivec_generator.h
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/compiler/objectivec/objectivec_helpers.h
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/compiler/php/php_generator.h
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/compiler/plugin.h
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/compiler/python/generator.h
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/compiler/python/pyi_generator.h
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/compiler/python/python_generator.h
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/compiler/ruby/ruby_generator.h
|
||||
)
|
||||
|
||||
add_library(libprotoc ${protobuf_SHARED_OR_STATIC}
|
||||
${libprotoc_files} ${libprotoc_headers} ${protobuf_version_rc_file})
|
||||
if(protobuf_HAVE_LD_VERSION_SCRIPT)
|
||||
if(${CMAKE_VERSION} VERSION_GREATER 3.13 OR ${CMAKE_VERSION} VERSION_EQUAL 3.13)
|
||||
target_link_options(libprotoc PRIVATE -Wl,--version-script=${protobuf_SOURCE_DIR}/src/libprotoc.map)
|
||||
elseif(protobuf_BUILD_SHARED_LIBS)
|
||||
target_link_libraries(libprotoc PRIVATE -Wl,--version-script=${protobuf_SOURCE_DIR}/src/libprotoc.map)
|
||||
endif()
|
||||
set_target_properties(libprotoc PROPERTIES
|
||||
LINK_DEPENDS ${protobuf_SOURCE_DIR}/src/libprotoc.map)
|
||||
endif()
|
||||
target_link_libraries(libprotoc PRIVATE libprotobuf)
|
||||
if(protobuf_BUILD_SHARED_LIBS)
|
||||
target_compile_definitions(libprotoc
|
||||
PUBLIC PROTOBUF_USE_DLLS
|
||||
PRIVATE LIBPROTOC_EXPORTS)
|
||||
endif()
|
||||
set_target_properties(libprotoc PROPERTIES
|
||||
COMPILE_DEFINITIONS LIBPROTOC_EXPORTS
|
||||
VERSION ${protobuf_VERSION}
|
||||
SOVERSION 32
|
||||
OUTPUT_NAME ${LIB_PREFIX}protoc
|
||||
DEBUG_POSTFIX "${protobuf_DEBUG_POSTFIX}")
|
||||
add_library(protobuf::libprotoc ALIAS libprotoc)
|
||||
@ -0,0 +1,60 @@
|
||||
set(PACKAGE_VERSION "@protobuf_VERSION@")
|
||||
set(${PACKAGE_FIND_NAME}_VERSION_PRERELEASE "@protobuf_VERSION_PRERELEASE@" PARENT_SCOPE)
|
||||
|
||||
# Prerelease versions cannot be passed in directly via the find_package command,
|
||||
# so we allow users to specify it in a variable
|
||||
if(NOT DEFINED "${PACKAGE_FIND_NAME}_FIND_VERSION_PRERELEASE")
|
||||
set("${${PACKAGE_FIND_NAME}_FIND_VERSION_PRERELEASE}" "")
|
||||
else()
|
||||
set(PACKAGE_FIND_VERSION ${PACKAGE_FIND_VERSION}-${${PACKAGE_FIND_NAME}_FIND_VERSION_PRERELEASE})
|
||||
endif()
|
||||
set(PACKAGE_FIND_VERSION_PRERELEASE "${${PACKAGE_FIND_NAME}_FIND_VERSION_PRERELEASE}")
|
||||
|
||||
# VERSION_EQUAL ignores the prerelease strings, so we use STREQUAL.
|
||||
if(PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION)
|
||||
set(PACKAGE_VERSION_EXACT TRUE)
|
||||
endif()
|
||||
|
||||
set(PACKAGE_VERSION_COMPATIBLE TRUE) #Assume true until shown otherwise
|
||||
|
||||
if(PACKAGE_FIND_VERSION) #Only perform version checks if one is given
|
||||
if(NOT PACKAGE_FIND_VERSION_MAJOR EQUAL "@protobuf_VERSION_MAJOR@")
|
||||
set(PACKAGE_VERSION_COMPATIBLE FALSE)
|
||||
elseif(PACKAGE_FIND_VERSION VERSION_GREATER PACKAGE_VERSION)
|
||||
set(PACKAGE_VERSION_COMPATIBLE FALSE)
|
||||
elseif(PACKAGE_FIND_VERSION VERSION_EQUAL PACKAGE_VERSION)
|
||||
# Do not match prerelease versions to non-prerelease version requests.
|
||||
if(NOT "@protobuf_VERSION_PRERELEASE@" STREQUAL "" AND PACKAGE_FIND_VERSION_PRERELEASE STREQUAL "")
|
||||
message(AUTHOR_WARNING "To use this prerelease version of ${PACKAGE_FIND_NAME}, set ${PACKAGE_FIND_NAME}_FIND_VERSION_PRERELEASE to '@protobuf_VERSION_PRERELEASE@' or greater.")
|
||||
set(PACKAGE_VERSION_COMPATIBLE FALSE)
|
||||
endif()
|
||||
|
||||
# Not robustly SemVer compliant, but protobuf never uses '.' separated prerelease identifiers.
|
||||
if(PACKAGE_FIND_VERSION_PRERELEASE STRGREATER "@protobuf_VERSION_PRERELEASE@")
|
||||
set(PACKAGE_VERSION_COMPATIBLE FALSE)
|
||||
endif()
|
||||
endif()
|
||||
endif()
|
||||
|
||||
# Check and save build options used to create this package
|
||||
macro(_check_and_save_build_option OPTION VALUE)
|
||||
if(DEFINED ${PACKAGE_FIND_NAME}_${OPTION} AND
|
||||
NOT ${PACKAGE_FIND_NAME}_${OPTION} STREQUAL ${VALUE})
|
||||
set(PACKAGE_VERSION_UNSUITABLE TRUE)
|
||||
endif()
|
||||
set(${PACKAGE_FIND_NAME}_${OPTION} ${VALUE} PARENT_SCOPE)
|
||||
endmacro()
|
||||
_check_and_save_build_option(WITH_ZLIB @protobuf_WITH_ZLIB@)
|
||||
_check_and_save_build_option(MSVC_STATIC_RUNTIME @protobuf_MSVC_STATIC_RUNTIME@)
|
||||
_check_and_save_build_option(BUILD_SHARED_LIBS @protobuf_BUILD_SHARED_LIBS@)
|
||||
|
||||
# if the installed or the using project don't have CMAKE_SIZEOF_VOID_P set, ignore it:
|
||||
if(CMAKE_SIZEOF_VOID_P AND "@CMAKE_SIZEOF_VOID_P@")
|
||||
# check that the installed version has the same 32/64bit-ness as the one which is currently searching:
|
||||
if(NOT CMAKE_SIZEOF_VOID_P EQUAL "@CMAKE_SIZEOF_VOID_P@")
|
||||
math(EXPR installedBits "@CMAKE_SIZEOF_VOID_P@ * 8")
|
||||
set(PACKAGE_VERSION "${PACKAGE_VERSION} (${installedBits}bit)")
|
||||
set(PACKAGE_VERSION_UNSUITABLE TRUE)
|
||||
endif()
|
||||
endif()
|
||||
|
||||
@ -0,0 +1,169 @@
|
||||
# User options
|
||||
include("${CMAKE_CURRENT_LIST_DIR}/protobuf-options.cmake")
|
||||
|
||||
# Depend packages
|
||||
@_protobuf_FIND_ZLIB@
|
||||
|
||||
# Imported targets
|
||||
include("${CMAKE_CURRENT_LIST_DIR}/protobuf-targets.cmake")
|
||||
|
||||
function(protobuf_generate)
|
||||
include(CMakeParseArguments)
|
||||
|
||||
set(_options APPEND_PATH)
|
||||
set(_singleargs LANGUAGE OUT_VAR EXPORT_MACRO PROTOC_OUT_DIR PLUGIN PLUGIN_OPTIONS)
|
||||
if(COMMAND target_sources)
|
||||
list(APPEND _singleargs TARGET)
|
||||
endif()
|
||||
set(_multiargs PROTOS IMPORT_DIRS GENERATE_EXTENSIONS PROTOC_OPTIONS)
|
||||
|
||||
cmake_parse_arguments(protobuf_generate "${_options}" "${_singleargs}" "${_multiargs}" "${ARGN}")
|
||||
|
||||
if(NOT protobuf_generate_PROTOS AND NOT protobuf_generate_TARGET)
|
||||
message(SEND_ERROR "Error: protobuf_generate called without any targets or source files")
|
||||
return()
|
||||
endif()
|
||||
|
||||
if(NOT protobuf_generate_OUT_VAR AND NOT protobuf_generate_TARGET)
|
||||
message(SEND_ERROR "Error: protobuf_generate called without a target or output variable")
|
||||
return()
|
||||
endif()
|
||||
|
||||
if(NOT protobuf_generate_LANGUAGE)
|
||||
set(protobuf_generate_LANGUAGE cpp)
|
||||
endif()
|
||||
string(TOLOWER ${protobuf_generate_LANGUAGE} protobuf_generate_LANGUAGE)
|
||||
|
||||
if(NOT protobuf_generate_PROTOC_OUT_DIR)
|
||||
set(protobuf_generate_PROTOC_OUT_DIR ${CMAKE_CURRENT_BINARY_DIR})
|
||||
endif()
|
||||
|
||||
if(protobuf_generate_EXPORT_MACRO AND protobuf_generate_LANGUAGE STREQUAL cpp)
|
||||
set(_dll_export_decl "dllexport_decl=${protobuf_generate_EXPORT_MACRO}")
|
||||
endif()
|
||||
|
||||
foreach(_option ${_dll_export_decl} ${protobuf_generate_PLUGIN_OPTIONS})
|
||||
# append comma - not using CMake lists and string replacement as users
|
||||
# might have semicolons in options
|
||||
if(_plugin_options)
|
||||
set( _plugin_options "${_plugin_options},")
|
||||
endif()
|
||||
set(_plugin_options "${_plugin_options}${_option}")
|
||||
endforeach()
|
||||
|
||||
if(protobuf_generate_PLUGIN)
|
||||
set(_plugin "--plugin=${protobuf_generate_PLUGIN}")
|
||||
endif()
|
||||
|
||||
if(NOT protobuf_generate_GENERATE_EXTENSIONS)
|
||||
if(protobuf_generate_LANGUAGE STREQUAL cpp)
|
||||
set(protobuf_generate_GENERATE_EXTENSIONS .pb.h .pb.cc)
|
||||
elseif(protobuf_generate_LANGUAGE STREQUAL python)
|
||||
set(protobuf_generate_GENERATE_EXTENSIONS _pb2.py)
|
||||
else()
|
||||
message(SEND_ERROR "Error: protobuf_generate given unknown Language ${LANGUAGE}, please provide a value for GENERATE_EXTENSIONS")
|
||||
return()
|
||||
endif()
|
||||
endif()
|
||||
|
||||
if(protobuf_generate_TARGET)
|
||||
get_target_property(_source_list ${protobuf_generate_TARGET} SOURCES)
|
||||
foreach(_file ${_source_list})
|
||||
if(_file MATCHES "proto$")
|
||||
list(APPEND protobuf_generate_PROTOS ${_file})
|
||||
endif()
|
||||
endforeach()
|
||||
endif()
|
||||
|
||||
if(NOT protobuf_generate_PROTOS)
|
||||
message(SEND_ERROR "Error: protobuf_generate could not find any .proto files")
|
||||
return()
|
||||
endif()
|
||||
|
||||
if(protobuf_generate_APPEND_PATH)
|
||||
# Create an include path for each file specified
|
||||
foreach(_file ${protobuf_generate_PROTOS})
|
||||
get_filename_component(_abs_file ${_file} ABSOLUTE)
|
||||
get_filename_component(_abs_dir ${_abs_file} DIRECTORY)
|
||||
list(FIND _protobuf_include_path ${_abs_dir} _contains_already)
|
||||
if(${_contains_already} EQUAL -1)
|
||||
list(APPEND _protobuf_include_path -I ${_abs_dir})
|
||||
endif()
|
||||
endforeach()
|
||||
endif()
|
||||
|
||||
foreach(DIR ${protobuf_generate_IMPORT_DIRS})
|
||||
get_filename_component(ABS_PATH ${DIR} ABSOLUTE)
|
||||
list(FIND _protobuf_include_path ${ABS_PATH} _contains_already)
|
||||
if(${_contains_already} EQUAL -1)
|
||||
list(APPEND _protobuf_include_path -I ${ABS_PATH})
|
||||
endif()
|
||||
endforeach()
|
||||
|
||||
if(NOT _protobuf_include_path)
|
||||
set(_protobuf_include_path -I ${CMAKE_CURRENT_SOURCE_DIR})
|
||||
endif()
|
||||
|
||||
set(_generated_srcs_all)
|
||||
foreach(_proto ${protobuf_generate_PROTOS})
|
||||
get_filename_component(_abs_file ${_proto} ABSOLUTE)
|
||||
get_filename_component(_abs_dir ${_abs_file} DIRECTORY)
|
||||
|
||||
get_filename_component(_file_full_name ${_proto} NAME)
|
||||
string(FIND "${_file_full_name}" "." _file_last_ext_pos REVERSE)
|
||||
string(SUBSTRING "${_file_full_name}" 0 ${_file_last_ext_pos} _basename)
|
||||
|
||||
set(_suitable_include_found FALSE)
|
||||
foreach(DIR ${_protobuf_include_path})
|
||||
if(NOT DIR STREQUAL "-I")
|
||||
file(RELATIVE_PATH _rel_dir ${DIR} ${_abs_dir})
|
||||
string(FIND "${_rel_dir}" "../" _is_in_parent_folder)
|
||||
if (NOT ${_is_in_parent_folder} EQUAL 0)
|
||||
set(_suitable_include_found TRUE)
|
||||
break()
|
||||
endif()
|
||||
endif()
|
||||
endforeach()
|
||||
|
||||
if(NOT _suitable_include_found)
|
||||
message(SEND_ERROR "Error: protobuf_generate could not find any correct proto include directory.")
|
||||
return()
|
||||
endif()
|
||||
|
||||
set(_generated_srcs)
|
||||
foreach(_ext ${protobuf_generate_GENERATE_EXTENSIONS})
|
||||
list(APPEND _generated_srcs "${protobuf_generate_PROTOC_OUT_DIR}/${_rel_dir}/${_basename}${_ext}")
|
||||
endforeach()
|
||||
list(APPEND _generated_srcs_all ${_generated_srcs})
|
||||
|
||||
set(_comment "Running ${protobuf_generate_LANGUAGE} protocol buffer compiler on ${_proto}")
|
||||
if(protobuf_generate_PROTOC_OPTIONS)
|
||||
set(_comment "${_comment}, protoc-options: ${protobuf_generate_PROTOC_OPTIONS}")
|
||||
endif()
|
||||
if(_plugin_options)
|
||||
set(_comment "${_comment}, plugin-options: ${_plugin_options}")
|
||||
endif()
|
||||
|
||||
add_custom_command(
|
||||
OUTPUT ${_generated_srcs}
|
||||
COMMAND protobuf::protoc
|
||||
ARGS ${protobuf_generate_PROTOC_OPTIONS} --${protobuf_generate_LANGUAGE}_out ${_plugin_options}:${protobuf_generate_PROTOC_OUT_DIR} ${_plugin} ${_protobuf_include_path} ${_abs_file}
|
||||
DEPENDS ${_abs_file} protobuf::protoc
|
||||
COMMENT ${_comment}
|
||||
VERBATIM )
|
||||
endforeach()
|
||||
|
||||
set_source_files_properties(${_generated_srcs_all} PROPERTIES GENERATED TRUE)
|
||||
if(protobuf_generate_OUT_VAR)
|
||||
set(${protobuf_generate_OUT_VAR} ${_generated_srcs_all} PARENT_SCOPE)
|
||||
endif()
|
||||
if(protobuf_generate_TARGET)
|
||||
target_sources(${protobuf_generate_TARGET} PRIVATE ${_generated_srcs_all})
|
||||
endif()
|
||||
|
||||
endfunction()
|
||||
|
||||
# CMake FindProtobuf module compatible file
|
||||
if(protobuf_MODULE_COMPATIBLE)
|
||||
include("${CMAKE_CURRENT_LIST_DIR}/protobuf-module.cmake")
|
||||
endif()
|
||||
@ -0,0 +1,11 @@
|
||||
prefix=@CMAKE_INSTALL_PREFIX@
|
||||
exec_prefix=@CMAKE_INSTALL_PREFIX@
|
||||
libdir=@CMAKE_INSTALL_FULL_LIBDIR@
|
||||
includedir=@CMAKE_INSTALL_FULL_INCLUDEDIR@
|
||||
|
||||
Name: Protocol Buffers
|
||||
Description: Google's Data Interchange Format
|
||||
Version: @protobuf_VERSION@
|
||||
Libs: -L${libdir} -lprotobuf-lite @CMAKE_THREAD_LIBS_INIT@
|
||||
Cflags: -I${includedir}
|
||||
Conflicts: protobuf
|
||||
@ -0,0 +1,189 @@
|
||||
# This file contains backwards compatibility patches for various legacy functions and variables
|
||||
# Functions
|
||||
|
||||
function(PROTOBUF_GENERATE_CPP SRCS HDRS)
|
||||
cmake_parse_arguments(protobuf_generate_cpp "" "EXPORT_MACRO" "" ${ARGN})
|
||||
|
||||
set(_proto_files "${protobuf_generate_cpp_UNPARSED_ARGUMENTS}")
|
||||
if(NOT _proto_files)
|
||||
message(SEND_ERROR "Error: PROTOBUF_GENERATE_CPP() called without any proto files")
|
||||
return()
|
||||
endif()
|
||||
|
||||
if(PROTOBUF_GENERATE_CPP_APPEND_PATH)
|
||||
set(_append_arg APPEND_PATH)
|
||||
endif()
|
||||
|
||||
if(DEFINED Protobuf_IMPORT_DIRS)
|
||||
set(_import_arg IMPORT_DIRS ${Protobuf_IMPORT_DIRS})
|
||||
endif()
|
||||
|
||||
set(_outvar)
|
||||
protobuf_generate(${_append_arg} LANGUAGE cpp EXPORT_MACRO ${protobuf_generate_cpp_EXPORT_MACRO} OUT_VAR _outvar ${_import_arg} PROTOS ${_proto_files})
|
||||
|
||||
set(${SRCS})
|
||||
set(${HDRS})
|
||||
foreach(_file ${_outvar})
|
||||
if(_file MATCHES "cc$")
|
||||
list(APPEND ${SRCS} ${_file})
|
||||
else()
|
||||
list(APPEND ${HDRS} ${_file})
|
||||
endif()
|
||||
endforeach()
|
||||
set(${SRCS} ${${SRCS}} PARENT_SCOPE)
|
||||
set(${HDRS} ${${HDRS}} PARENT_SCOPE)
|
||||
endfunction()
|
||||
|
||||
function(PROTOBUF_GENERATE_PYTHON SRCS)
|
||||
if(NOT ARGN)
|
||||
message(SEND_ERROR "Error: PROTOBUF_GENERATE_PYTHON() called without any proto files")
|
||||
return()
|
||||
endif()
|
||||
|
||||
if(PROTOBUF_GENERATE_CPP_APPEND_PATH)
|
||||
set(_append_arg APPEND_PATH)
|
||||
endif()
|
||||
|
||||
if(DEFINED Protobuf_IMPORT_DIRS)
|
||||
set(_import_arg IMPORT_DIRS ${Protobuf_IMPORT_DIRS})
|
||||
endif()
|
||||
|
||||
set(_outvar)
|
||||
protobuf_generate(${_append_arg} LANGUAGE python OUT_VAR _outvar ${_import_arg} PROTOS ${ARGN})
|
||||
set(${SRCS} ${_outvar} PARENT_SCOPE)
|
||||
endfunction()
|
||||
|
||||
# Environment
|
||||
|
||||
# Backwards compatibility
|
||||
# Define camel case versions of input variables
|
||||
foreach(UPPER
|
||||
PROTOBUF_SRC_ROOT_FOLDER
|
||||
PROTOBUF_IMPORT_DIRS
|
||||
PROTOBUF_DEBUG
|
||||
PROTOBUF_LIBRARY
|
||||
PROTOBUF_PROTOC_LIBRARY
|
||||
PROTOBUF_INCLUDE_DIR
|
||||
PROTOBUF_PROTOC_EXECUTABLE
|
||||
PROTOBUF_LIBRARY_DEBUG
|
||||
PROTOBUF_PROTOC_LIBRARY_DEBUG
|
||||
PROTOBUF_LITE_LIBRARY
|
||||
PROTOBUF_LITE_LIBRARY_DEBUG
|
||||
)
|
||||
if (DEFINED ${UPPER})
|
||||
string(REPLACE "PROTOBUF_" "Protobuf_" Camel ${UPPER})
|
||||
if (NOT DEFINED ${Camel})
|
||||
set(${Camel} ${${UPPER}})
|
||||
endif()
|
||||
endif()
|
||||
endforeach()
|
||||
|
||||
if(DEFINED Protobuf_SRC_ROOT_FOLDER)
|
||||
message(AUTHOR_WARNING "Variable Protobuf_SRC_ROOT_FOLDER defined, but not"
|
||||
" used in CONFIG mode")
|
||||
endif()
|
||||
|
||||
include(SelectLibraryConfigurations)
|
||||
|
||||
# Internal function: search for normal library as well as a debug one
|
||||
# if the debug one is specified also include debug/optimized keywords
|
||||
# in *_LIBRARIES variable
|
||||
function(_protobuf_find_libraries name filename)
|
||||
if(${name}_LIBRARIES)
|
||||
# Use result recorded by a previous call.
|
||||
elseif(${name}_LIBRARY)
|
||||
# Honor cache entry used by CMake 3.5 and lower.
|
||||
set(${name}_LIBRARIES "${${name}_LIBRARY}" PARENT_SCOPE)
|
||||
elseif(TARGET protobuf::lib${filename})
|
||||
get_target_property(${name}_LIBRARY_RELEASE protobuf::lib${filename}
|
||||
LOCATION_RELEASE)
|
||||
get_target_property(${name}_LIBRARY_RELWITHDEBINFO protobuf::lib${filename}
|
||||
LOCATION_RELWITHDEBINFO)
|
||||
get_target_property(${name}_LIBRARY_MINSIZEREL protobuf::lib${filename}
|
||||
LOCATION_MINSIZEREL)
|
||||
get_target_property(${name}_LIBRARY_DEBUG protobuf::lib${filename}
|
||||
LOCATION_DEBUG)
|
||||
|
||||
select_library_configurations(${name})
|
||||
set(${name}_LIBRARY ${${name}_LIBRARY} PARENT_SCOPE)
|
||||
set(${name}_LIBRARIES ${${name}_LIBRARIES} PARENT_SCOPE)
|
||||
endif()
|
||||
endfunction()
|
||||
|
||||
#
|
||||
# Main.
|
||||
#
|
||||
|
||||
# By default have PROTOBUF_GENERATE_CPP macro pass -I to protoc
|
||||
# for each directory where a proto file is referenced.
|
||||
if(NOT DEFINED PROTOBUF_GENERATE_CPP_APPEND_PATH)
|
||||
set(PROTOBUF_GENERATE_CPP_APPEND_PATH TRUE)
|
||||
endif()
|
||||
|
||||
# The Protobuf library
|
||||
_protobuf_find_libraries(Protobuf protobuf)
|
||||
|
||||
# The Protobuf Lite library
|
||||
_protobuf_find_libraries(Protobuf_LITE protobuf-lite)
|
||||
|
||||
# The Protobuf Protoc Library
|
||||
_protobuf_find_libraries(Protobuf_PROTOC protoc)
|
||||
|
||||
# Set the include directory
|
||||
get_target_property(Protobuf_INCLUDE_DIRS protobuf::libprotobuf
|
||||
INTERFACE_INCLUDE_DIRECTORIES)
|
||||
|
||||
# Set the protoc Executable
|
||||
if(NOT Protobuf_PROTOC_EXECUTABLE AND TARGET protobuf::protoc)
|
||||
get_target_property(Protobuf_PROTOC_EXECUTABLE protobuf::protoc
|
||||
IMPORTED_LOCATION_RELEASE)
|
||||
if(NOT EXISTS "${Protobuf_PROTOC_EXECUTABLE}")
|
||||
get_target_property(Protobuf_PROTOC_EXECUTABLE protobuf::protoc
|
||||
IMPORTED_LOCATION_RELWITHDEBINFO)
|
||||
endif()
|
||||
if(NOT EXISTS "${Protobuf_PROTOC_EXECUTABLE}")
|
||||
get_target_property(Protobuf_PROTOC_EXECUTABLE protobuf::protoc
|
||||
IMPORTED_LOCATION_MINSIZEREL)
|
||||
endif()
|
||||
if(NOT EXISTS "${Protobuf_PROTOC_EXECUTABLE}")
|
||||
get_target_property(Protobuf_PROTOC_EXECUTABLE protobuf::protoc
|
||||
IMPORTED_LOCATION_DEBUG)
|
||||
endif()
|
||||
if(NOT EXISTS "${Protobuf_PROTOC_EXECUTABLE}")
|
||||
get_target_property(Protobuf_PROTOC_EXECUTABLE protobuf::protoc
|
||||
IMPORTED_LOCATION_NOCONFIG)
|
||||
endif()
|
||||
endif()
|
||||
|
||||
# Version info variable
|
||||
set(Protobuf_VERSION "@protobuf_VERSION@")
|
||||
|
||||
include(FindPackageHandleStandardArgs)
|
||||
FIND_PACKAGE_HANDLE_STANDARD_ARGS(Protobuf
|
||||
REQUIRED_VARS Protobuf_PROTOC_EXECUTABLE Protobuf_LIBRARIES Protobuf_INCLUDE_DIRS
|
||||
VERSION_VAR Protobuf_VERSION
|
||||
)
|
||||
|
||||
# Backwards compatibility
|
||||
# Define upper case versions of output variables
|
||||
foreach(Camel
|
||||
Protobuf_VERSION
|
||||
Protobuf_SRC_ROOT_FOLDER
|
||||
Protobuf_IMPORT_DIRS
|
||||
Protobuf_DEBUG
|
||||
Protobuf_INCLUDE_DIRS
|
||||
Protobuf_LIBRARIES
|
||||
Protobuf_PROTOC_LIBRARIES
|
||||
Protobuf_LITE_LIBRARIES
|
||||
Protobuf_LIBRARY
|
||||
Protobuf_PROTOC_LIBRARY
|
||||
Protobuf_INCLUDE_DIR
|
||||
Protobuf_PROTOC_EXECUTABLE
|
||||
Protobuf_LIBRARY_DEBUG
|
||||
Protobuf_PROTOC_LIBRARY_DEBUG
|
||||
Protobuf_LITE_LIBRARY
|
||||
Protobuf_LITE_LIBRARY_DEBUG
|
||||
)
|
||||
string(TOUPPER ${Camel} UPPER)
|
||||
set(${UPPER} ${${Camel}})
|
||||
endforeach()
|
||||
@ -0,0 +1,7 @@
|
||||
# Verbose output
|
||||
option(protobuf_VERBOSE "Enable for verbose output" OFF)
|
||||
mark_as_advanced(protobuf_VERBOSE)
|
||||
|
||||
# FindProtobuf module compatible
|
||||
option(protobuf_MODULE_COMPATIBLE "CMake built-in FindProtobuf.cmake module compatible" OFF)
|
||||
mark_as_advanced(protobuf_MODULE_COMPATIBLE)
|
||||
@ -0,0 +1,11 @@
|
||||
prefix=@CMAKE_INSTALL_PREFIX@
|
||||
exec_prefix=@CMAKE_INSTALL_PREFIX@
|
||||
libdir=@CMAKE_INSTALL_FULL_LIBDIR@
|
||||
includedir=@CMAKE_INSTALL_FULL_INCLUDEDIR@
|
||||
|
||||
Name: Protocol Buffers
|
||||
Description: Google's Data Interchange Format
|
||||
Version: @protobuf_VERSION@
|
||||
Libs: -L${libdir} -lprotobuf @CMAKE_THREAD_LIBS_INIT@
|
||||
Cflags: -I${includedir}
|
||||
Conflicts: protobuf-lite
|
||||
@ -0,0 +1,13 @@
|
||||
set(protoc_files
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/compiler/main.cc
|
||||
)
|
||||
|
||||
add_executable(protoc ${protoc_files} ${protobuf_version_rc_file})
|
||||
target_link_libraries(protoc
|
||||
libprotoc
|
||||
libprotobuf
|
||||
)
|
||||
add_executable(protobuf::protoc ALIAS protoc)
|
||||
|
||||
set_target_properties(protoc PROPERTIES
|
||||
VERSION ${protobuf_VERSION})
|
||||
@ -0,0 +1,294 @@
|
||||
option(protobuf_USE_EXTERNAL_GTEST "Use external Google Test (i.e. not the one in third_party/googletest)" OFF)
|
||||
|
||||
option(protobuf_TEST_XML_OUTDIR "Output directory for XML logs from tests." "")
|
||||
|
||||
option(protobuf_ABSOLUTE_TEST_PLUGIN_PATH
|
||||
"Using absolute test_plugin path in tests" ON)
|
||||
mark_as_advanced(protobuf_ABSOLUTE_TEST_PLUGIN_PATH)
|
||||
|
||||
if (protobuf_USE_EXTERNAL_GTEST)
|
||||
find_package(GTest REQUIRED)
|
||||
else()
|
||||
if (NOT EXISTS "${protobuf_SOURCE_DIR}/third_party/googletest/CMakeLists.txt")
|
||||
message(FATAL_ERROR
|
||||
"Cannot find third_party/googletest directory that's needed to "
|
||||
"build tests. If you use git, make sure you have cloned submodules:\n"
|
||||
" git submodule update --init --recursive\n"
|
||||
"If instead you want to skip tests, run cmake with:\n"
|
||||
" cmake -Dprotobuf_BUILD_TESTS=OFF\n")
|
||||
endif()
|
||||
|
||||
set(googlemock_source_dir "${protobuf_SOURCE_DIR}/third_party/googletest/googlemock")
|
||||
set(googletest_source_dir "${protobuf_SOURCE_DIR}/third_party/googletest/googletest")
|
||||
include_directories(
|
||||
${googlemock_source_dir}
|
||||
${googletest_source_dir}
|
||||
${googletest_source_dir}/include
|
||||
${googlemock_source_dir}/include
|
||||
)
|
||||
|
||||
add_library(gmock STATIC
|
||||
"${googlemock_source_dir}/src/gmock-all.cc"
|
||||
"${googletest_source_dir}/src/gtest-all.cc"
|
||||
)
|
||||
target_link_libraries(gmock ${CMAKE_THREAD_LIBS_INIT})
|
||||
add_library(gmock_main STATIC "${googlemock_source_dir}/src/gmock_main.cc")
|
||||
target_link_libraries(gmock_main gmock)
|
||||
|
||||
add_library(GTest::gmock ALIAS gmock)
|
||||
add_library(GTest::gmock_main ALIAS gmock_main)
|
||||
endif()
|
||||
|
||||
set(lite_test_protos
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/map_lite_unittest.proto
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/unittest_import_lite.proto
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/unittest_import_public_lite.proto
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/unittest_lite.proto
|
||||
)
|
||||
|
||||
set(tests_protos
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/any_test.proto
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/compiler/cpp/test_bad_identifiers.proto
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/compiler/cpp/test_large_enum_value.proto
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/map_proto2_unittest.proto
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/map_unittest.proto
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/unittest.proto
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/unittest_arena.proto
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/unittest_custom_options.proto
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/unittest_drop_unknown_fields.proto
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/unittest_embed_optimize_for.proto
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/unittest_empty.proto
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/unittest_enormous_descriptor.proto
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/unittest_import.proto
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/unittest_import_public.proto
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/unittest_lazy_dependencies.proto
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/unittest_lazy_dependencies_custom_option.proto
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/unittest_lazy_dependencies_enum.proto
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/unittest_lite_imports_nonlite.proto
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/unittest_mset.proto
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/unittest_mset_wire_format.proto
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/unittest_no_field_presence.proto
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/unittest_no_generic_services.proto
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/unittest_optimize_for.proto
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/unittest_preserve_unknown_enum.proto
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/unittest_preserve_unknown_enum2.proto
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/unittest_proto3.proto
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/unittest_proto3_arena.proto
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/unittest_proto3_arena_lite.proto
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/unittest_proto3_lite.proto
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/unittest_proto3_optional.proto
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/unittest_well_known_types.proto
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/util/internal/testdata/anys.proto
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/util/internal/testdata/books.proto
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/util/internal/testdata/default_value.proto
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/util/internal/testdata/default_value_test.proto
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/util/internal/testdata/field_mask.proto
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/util/internal/testdata/maps.proto
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/util/internal/testdata/oneofs.proto
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/util/internal/testdata/proto3.proto
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/util/internal/testdata/struct.proto
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/util/internal/testdata/timestamp_duration.proto
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/util/internal/testdata/wrappers.proto
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/util/json_format.proto
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/util/json_format_proto3.proto
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/util/message_differencer_unittest.proto
|
||||
)
|
||||
|
||||
macro(compile_proto_file filename)
|
||||
string(REPLACE .proto .pb.cc pb_file ${filename})
|
||||
add_custom_command(
|
||||
OUTPUT ${pb_file}
|
||||
DEPENDS ${protobuf_PROTOC_EXE} ${filename}
|
||||
COMMAND ${protobuf_PROTOC_EXE} ${filename}
|
||||
--proto_path=${protobuf_SOURCE_DIR}/src
|
||||
--cpp_out=${protobuf_SOURCE_DIR}/src
|
||||
--experimental_allow_proto3_optional
|
||||
)
|
||||
endmacro(compile_proto_file)
|
||||
|
||||
set(lite_test_proto_files)
|
||||
foreach(proto_file ${lite_test_protos})
|
||||
compile_proto_file(${proto_file})
|
||||
set(lite_test_proto_files ${lite_test_proto_files} ${pb_file})
|
||||
endforeach(proto_file)
|
||||
|
||||
set(tests_proto_files)
|
||||
foreach(proto_file ${tests_protos})
|
||||
compile_proto_file(${proto_file})
|
||||
set(tests_proto_files ${tests_proto_files} ${pb_file})
|
||||
endforeach(proto_file)
|
||||
|
||||
set(common_lite_test_files
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/arena_test_util.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/map_lite_test_util.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/test_util_lite.cc
|
||||
)
|
||||
|
||||
add_library(protobuf-lite-test-common STATIC
|
||||
${common_lite_test_files} ${lite_test_proto_files})
|
||||
target_link_libraries(protobuf-lite-test-common libprotobuf-lite GTest::gmock)
|
||||
|
||||
set(common_test_files
|
||||
${common_lite_test_files}
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/compiler/mock_code_generator.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/map_test_util.inc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/reflection_tester.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/test_util.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/testing/file.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/testing/googletest.cc
|
||||
)
|
||||
|
||||
add_library(protobuf-test-common STATIC
|
||||
${common_test_files} ${tests_proto_files})
|
||||
target_link_libraries(protobuf-test-common libprotobuf GTest::gmock)
|
||||
|
||||
set(tests_files
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/any_test.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/arena_unittest.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/arenastring_unittest.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/arenaz_sampler_test.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/compiler/annotation_test_util.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/compiler/annotation_test_util.h
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/compiler/command_line_interface_unittest.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/compiler/cpp/bootstrap_unittest.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/compiler/cpp/message_size_unittest.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/compiler/cpp/metadata_test.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/compiler/cpp/move_unittest.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/compiler/cpp/plugin_unittest.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/compiler/cpp/unittest.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/compiler/cpp/unittest.inc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/compiler/csharp/csharp_bootstrap_unittest.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/compiler/csharp/csharp_generator_unittest.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/compiler/importer_unittest.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/compiler/java/doc_comment_unittest.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/compiler/java/plugin_unittest.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/compiler/objectivec/objectivec_helpers_unittest.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/compiler/parser_unittest.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/compiler/python/plugin_unittest.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/compiler/ruby/ruby_generator_unittest.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/descriptor_database_unittest.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/descriptor_unittest.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/drop_unknown_fields_test.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/dynamic_message_unittest.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/extension_set_unittest.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/generated_message_reflection_unittest.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/generated_message_tctable_lite_test.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/inlined_string_field_unittest.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/io/coded_stream_unittest.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/io/io_win32_unittest.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/io/printer_unittest.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/io/tokenizer_unittest.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/io/zero_copy_stream_unittest.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/map_field_test.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/map_test.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/map_test.inc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/message_unittest.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/message_unittest.inc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/no_field_presence_test.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/preserve_unknown_enum_test.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/proto3_arena_lite_unittest.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/proto3_arena_unittest.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/proto3_lite_unittest.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/proto3_lite_unittest.inc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/reflection_ops_unittest.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/repeated_field_reflection_unittest.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/repeated_field_unittest.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/stubs/bytestream_unittest.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/stubs/common_unittest.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/stubs/int128_unittest.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/stubs/status_test.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/stubs/statusor_test.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/stubs/stringpiece_unittest.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/stubs/stringprintf_unittest.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/stubs/structurally_valid_unittest.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/stubs/strutil_unittest.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/stubs/template_util_unittest.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/stubs/time_test.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/text_format_unittest.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/unknown_field_set_unittest.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/util/delimited_message_util_test.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/util/field_comparator_test.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/util/field_mask_util_test.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/util/internal/default_value_objectwriter_test.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/util/internal/json_objectwriter_test.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/util/internal/json_stream_parser_test.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/util/internal/protostream_objectsource_test.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/util/internal/protostream_objectwriter_test.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/util/internal/type_info_test_helper.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/util/json_util_test.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/util/message_differencer_unittest.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/util/time_util_test.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/util/type_resolver_util_test.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/well_known_types_unittest.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/wire_format_unittest.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/wire_format_unittest.inc
|
||||
)
|
||||
|
||||
if(protobuf_ABSOLUTE_TEST_PLUGIN_PATH)
|
||||
add_compile_options(-DGOOGLE_PROTOBUF_TEST_PLUGIN_PATH="$<TARGET_FILE:test_plugin>")
|
||||
endif()
|
||||
|
||||
if(MINGW)
|
||||
set_source_files_properties(${tests_files} PROPERTIES COMPILE_FLAGS "-Wno-narrowing")
|
||||
|
||||
# required for tests on MinGW Win64
|
||||
if (CMAKE_SIZEOF_VOID_P EQUAL 8)
|
||||
set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -Wl,--stack,16777216")
|
||||
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wa,-mbig-obj")
|
||||
endif()
|
||||
|
||||
endif()
|
||||
|
||||
if(protobuf_TEST_XML_OUTDIR)
|
||||
if(NOT "${protobuf_TEST_XML_OUTDIR}" MATCHES "[/\\]$")
|
||||
string(APPEND protobuf_TEST_XML_OUTDIR "/")
|
||||
endif()
|
||||
set(protobuf_GTEST_ARGS "--gtest_output=xml:${protobuf_TEST_XML_OUTDIR}")
|
||||
else()
|
||||
set(protobuf_GTEST_ARGS)
|
||||
endif()
|
||||
|
||||
add_executable(tests ${tests_files})
|
||||
if (MSVC)
|
||||
target_compile_options(tests PRIVATE
|
||||
/wd4146 # unary minus operator applied to unsigned type, result still unsigned
|
||||
)
|
||||
endif()
|
||||
target_link_libraries(tests protobuf-lite-test-common protobuf-test-common libprotoc libprotobuf GTest::gmock_main)
|
||||
|
||||
set(test_plugin_files
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/compiler/mock_code_generator.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/compiler/test_plugin.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/testing/file.cc
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/testing/file.h
|
||||
)
|
||||
|
||||
add_executable(test_plugin ${test_plugin_files})
|
||||
target_link_libraries(test_plugin libprotoc libprotobuf GTest::gmock)
|
||||
|
||||
set(lite_test_files
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/lite_unittest.cc
|
||||
)
|
||||
add_executable(lite-test ${lite_test_files})
|
||||
target_link_libraries(lite-test protobuf-lite-test-common libprotobuf-lite GTest::gmock_main)
|
||||
|
||||
add_test(NAME lite-test
|
||||
COMMAND lite-test ${protobuf_GTEST_ARGS})
|
||||
|
||||
set(lite_arena_test_files
|
||||
${protobuf_SOURCE_DIR}/src/google/protobuf/lite_arena_unittest.cc
|
||||
)
|
||||
add_executable(lite-arena-test ${lite_arena_test_files})
|
||||
target_link_libraries(lite-arena-test protobuf-lite-test-common libprotobuf-lite GTest::gmock_main)
|
||||
|
||||
add_test(NAME lite-arena-test
|
||||
COMMAND lite-arena-test ${protobuf_GTEST_ARGS})
|
||||
|
||||
add_custom_target(check
|
||||
COMMAND tests
|
||||
DEPENDS tests test_plugin
|
||||
WORKING_DIRECTORY ${protobuf_SOURCE_DIR})
|
||||
|
||||
add_test(NAME check
|
||||
COMMAND tests ${protobuf_GTEST_ARGS}
|
||||
WORKING_DIRECTORY "${protobuf_SOURCE_DIR}")
|
||||
@ -0,0 +1,45 @@
|
||||
#define VS_FF_DEBUG 0x1L
|
||||
#define VS_VERSION_INFO 0x1L
|
||||
#define VS_FFI_FILEFLAGSMASK 0x17L
|
||||
#define VER_PRIVATEBUILD 0x0L
|
||||
#define VER_PRERELEASE 0x0L
|
||||
#define VOS__WINDOWS32 0x4L
|
||||
#define VFT_DLL 0x2L
|
||||
#define VFT2_UNKNOWN 0x0L
|
||||
|
||||
#ifndef DEBUG
|
||||
#define VER_DEBUG 0
|
||||
#else
|
||||
#define VER_DEBUG VS_FF_DEBUG
|
||||
#endif
|
||||
|
||||
|
||||
VS_VERSION_INFO VERSIONINFO
|
||||
FILEVERSION @protobuf_RC_FILEVERSION@
|
||||
PRODUCTVERSION @protobuf_RC_FILEVERSION@
|
||||
FILEFLAGSMASK VS_FFI_FILEFLAGSMASK
|
||||
FILEFLAGS VER_DEBUG
|
||||
FILEOS VOS__WINDOWS32
|
||||
FILETYPE VFT_DLL
|
||||
BEGIN
|
||||
BLOCK "VarFileInfo"
|
||||
BEGIN
|
||||
// English language (0x409) and the Windows Unicode codepage (1200)
|
||||
VALUE "Translation", 0x409, 1200
|
||||
END
|
||||
BLOCK "StringFileInfo"
|
||||
BEGIN
|
||||
BLOCK "040904b0"
|
||||
BEGIN
|
||||
VALUE "FileDescription", "Compiled with @CMAKE_CXX_COMPILER_ID@ @CMAKE_CXX_COMPILER_VERSION@\0"
|
||||
VALUE "ProductVersion", "@protobuf_VERSION@\0"
|
||||
VALUE "FileVersion", "@protobuf_VERSION@\0"
|
||||
VALUE "InternalName", "protobuf\0"
|
||||
VALUE "ProductName", "Protocol Buffers - Google's Data Interchange Format\0"
|
||||
VALUE "CompanyName", "Google Inc.\0"
|
||||
VALUE "LegalCopyright", "Copyright 2008 Google Inc. All rights reserved.\0"
|
||||
VALUE "Licence", "BSD\0"
|
||||
VALUE "Info", "https://developers.google.com/protocol-buffers/\0"
|
||||
END
|
||||
END
|
||||
END
|
||||
File diff suppressed because it is too large
Load Diff
@ -1,12 +1,218 @@
|
||||
#define HASH_MAP_H @HASH_MAP_H@
|
||||
#define HASH_SET_H @HASH_SET_H@
|
||||
#define HASH_MAP_CLASS @HASH_MAP_CLASS@
|
||||
#define HASH_SET_CLASS @HASH_SET_CLASS@
|
||||
#define HASH_NAMESPACE @HASH_NAMESPACE@
|
||||
#define HAVE_HASH_MAP @HAVE_HASH_MAP@
|
||||
#define HAVE_HASH_SET @HAVE_HASH_SET@
|
||||
#define HAVE_PTHREAD @CMAKE_USE_PTHREADS_INIT@
|
||||
|
||||
/* define if you want to use zlib. See readme.txt for additional
|
||||
* requirements. */
|
||||
#define HAVE_ZLIB 1
|
||||
/* config.h.in. Generated from configure.ac by autoheader. */
|
||||
|
||||
/* the name of <hash_map> */
|
||||
#undef HASH_MAP_CLASS
|
||||
|
||||
/* the location of <unordered_map> or <hash_map> */
|
||||
#undef HASH_MAP_H
|
||||
|
||||
/* the namespace of hash_map/hash_set */
|
||||
#undef HASH_NAMESPACE
|
||||
|
||||
/* the name of <hash_set> */
|
||||
#undef HASH_SET_CLASS
|
||||
|
||||
/* the location of <unordered_set> or <hash_set> */
|
||||
#undef HASH_SET_H
|
||||
|
||||
/* define if the compiler supports basic C++11 syntax */
|
||||
#undef HAVE_CXX11
|
||||
|
||||
/* Define to 1 if you have the <dlfcn.h> header file. */
|
||||
#undef HAVE_DLFCN_H
|
||||
|
||||
/* Define to 1 if you have the <fcntl.h> header file. */
|
||||
#undef HAVE_FCNTL_H
|
||||
|
||||
/* Define to 1 if you have the `ftruncate' function. */
|
||||
#undef HAVE_FTRUNCATE
|
||||
|
||||
/* define if the compiler has hash_map */
|
||||
#undef HAVE_HASH_MAP
|
||||
|
||||
/* define if the compiler has hash_set */
|
||||
#undef HAVE_HASH_SET
|
||||
|
||||
/* Define to 1 if you have the <inttypes.h> header file. */
|
||||
#undef HAVE_INTTYPES_H
|
||||
|
||||
/* Define to 1 if you have the <limits.h> header file. */
|
||||
#undef HAVE_LIMITS_H
|
||||
|
||||
/* Define to 1 if you have the `memset' function. */
|
||||
#undef HAVE_MEMSET
|
||||
|
||||
/* Define to 1 if you have the <minix/config.h> header file. */
|
||||
#undef HAVE_MINIX_CONFIG_H
|
||||
|
||||
/* Define to 1 if you have the `mkdir' function. */
|
||||
#undef HAVE_MKDIR
|
||||
|
||||
/* Define if you have POSIX threads libraries and header files. */
|
||||
#undef HAVE_PTHREAD
|
||||
|
||||
/* Have PTHREAD_PRIO_INHERIT. */
|
||||
#undef HAVE_PTHREAD_PRIO_INHERIT
|
||||
|
||||
/* Define to 1 if you have the <stdint.h> header file. */
|
||||
#undef HAVE_STDINT_H
|
||||
|
||||
/* Define to 1 if you have the <stdio.h> header file. */
|
||||
#undef HAVE_STDIO_H
|
||||
|
||||
/* Define to 1 if you have the <stdlib.h> header file. */
|
||||
#undef HAVE_STDLIB_H
|
||||
|
||||
/* Define to 1 if you have the `strchr' function. */
|
||||
#undef HAVE_STRCHR
|
||||
|
||||
/* Define to 1 if you have the `strerror' function. */
|
||||
#undef HAVE_STRERROR
|
||||
|
||||
/* Define to 1 if you have the <strings.h> header file. */
|
||||
#undef HAVE_STRINGS_H
|
||||
|
||||
/* Define to 1 if you have the <string.h> header file. */
|
||||
#undef HAVE_STRING_H
|
||||
|
||||
/* Define to 1 if you have the `strtol' function. */
|
||||
#undef HAVE_STRTOL
|
||||
|
||||
/* Define to 1 if you have the <sys/stat.h> header file. */
|
||||
#undef HAVE_SYS_STAT_H
|
||||
|
||||
/* Define to 1 if you have the <sys/types.h> header file. */
|
||||
#undef HAVE_SYS_TYPES_H
|
||||
|
||||
/* Define to 1 if you have the <unistd.h> header file. */
|
||||
#undef HAVE_UNISTD_H
|
||||
|
||||
/* Define to 1 if you have the <wchar.h> header file. */
|
||||
#undef HAVE_WCHAR_H
|
||||
|
||||
/* Enable classes using zlib compression. */
|
||||
#undef HAVE_ZLIB
|
||||
|
||||
/* Define to the sub-directory where libtool stores uninstalled libraries. */
|
||||
#undef LT_OBJDIR
|
||||
|
||||
/* Name of package */
|
||||
#undef PACKAGE
|
||||
|
||||
/* Define to the address where bug reports for this package should be sent. */
|
||||
#undef PACKAGE_BUGREPORT
|
||||
|
||||
/* Define to the full name of this package. */
|
||||
#undef PACKAGE_NAME
|
||||
|
||||
/* Define to the full name and version of this package. */
|
||||
#undef PACKAGE_STRING
|
||||
|
||||
/* Define to the one symbol short name of this package. */
|
||||
#undef PACKAGE_TARNAME
|
||||
|
||||
/* Define to the home page for this package. */
|
||||
#undef PACKAGE_URL
|
||||
|
||||
/* Define to the version of this package. */
|
||||
#undef PACKAGE_VERSION
|
||||
|
||||
/* Define to necessary symbol if this constant uses a non-standard name on
|
||||
your system. */
|
||||
#undef PTHREAD_CREATE_JOINABLE
|
||||
|
||||
/* Define to 1 if all of the C90 standard headers exist (not just the ones
|
||||
required in a freestanding environment). This macro is provided for
|
||||
backward compatibility; new code need not use it. */
|
||||
#undef STDC_HEADERS
|
||||
|
||||
/* Enable extensions on AIX 3, Interix. */
|
||||
#ifndef _ALL_SOURCE
|
||||
# undef _ALL_SOURCE
|
||||
#endif
|
||||
/* Enable general extensions on macOS. */
|
||||
#ifndef _DARWIN_C_SOURCE
|
||||
# undef _DARWIN_C_SOURCE
|
||||
#endif
|
||||
/* Enable general extensions on Solaris. */
|
||||
#ifndef __EXTENSIONS__
|
||||
# undef __EXTENSIONS__
|
||||
#endif
|
||||
/* Enable GNU extensions on systems that have them. */
|
||||
#ifndef _GNU_SOURCE
|
||||
# undef _GNU_SOURCE
|
||||
#endif
|
||||
/* Enable X/Open compliant socket functions that do not require linking
|
||||
with -lxnet on HP-UX 11.11. */
|
||||
#ifndef _HPUX_ALT_XOPEN_SOCKET_API
|
||||
# undef _HPUX_ALT_XOPEN_SOCKET_API
|
||||
#endif
|
||||
/* Identify the host operating system as Minix.
|
||||
This macro does not affect the system headers' behavior.
|
||||
A future release of Autoconf may stop defining this macro. */
|
||||
#ifndef _MINIX
|
||||
# undef _MINIX
|
||||
#endif
|
||||
/* Enable general extensions on NetBSD.
|
||||
Enable NetBSD compatibility extensions on Minix. */
|
||||
#ifndef _NETBSD_SOURCE
|
||||
# undef _NETBSD_SOURCE
|
||||
#endif
|
||||
/* Enable OpenBSD compatibility extensions on NetBSD.
|
||||
Oddly enough, this does nothing on OpenBSD. */
|
||||
#ifndef _OPENBSD_SOURCE
|
||||
# undef _OPENBSD_SOURCE
|
||||
#endif
|
||||
/* Define to 1 if needed for POSIX-compatible behavior. */
|
||||
#ifndef _POSIX_SOURCE
|
||||
# undef _POSIX_SOURCE
|
||||
#endif
|
||||
/* Define to 2 if needed for POSIX-compatible behavior. */
|
||||
#ifndef _POSIX_1_SOURCE
|
||||
# undef _POSIX_1_SOURCE
|
||||
#endif
|
||||
/* Enable POSIX-compatible threading on Solaris. */
|
||||
#ifndef _POSIX_PTHREAD_SEMANTICS
|
||||
# undef _POSIX_PTHREAD_SEMANTICS
|
||||
#endif
|
||||
/* Enable extensions specified by ISO/IEC TS 18661-5:2014. */
|
||||
#ifndef __STDC_WANT_IEC_60559_ATTRIBS_EXT__
|
||||
# undef __STDC_WANT_IEC_60559_ATTRIBS_EXT__
|
||||
#endif
|
||||
/* Enable extensions specified by ISO/IEC TS 18661-1:2014. */
|
||||
#ifndef __STDC_WANT_IEC_60559_BFP_EXT__
|
||||
# undef __STDC_WANT_IEC_60559_BFP_EXT__
|
||||
#endif
|
||||
/* Enable extensions specified by ISO/IEC TS 18661-2:2015. */
|
||||
#ifndef __STDC_WANT_IEC_60559_DFP_EXT__
|
||||
# undef __STDC_WANT_IEC_60559_DFP_EXT__
|
||||
#endif
|
||||
/* Enable extensions specified by ISO/IEC TS 18661-4:2015. */
|
||||
#ifndef __STDC_WANT_IEC_60559_FUNCS_EXT__
|
||||
# undef __STDC_WANT_IEC_60559_FUNCS_EXT__
|
||||
#endif
|
||||
/* Enable extensions specified by ISO/IEC TS 18661-3:2015. */
|
||||
#ifndef __STDC_WANT_IEC_60559_TYPES_EXT__
|
||||
# undef __STDC_WANT_IEC_60559_TYPES_EXT__
|
||||
#endif
|
||||
/* Enable extensions specified by ISO/IEC TR 24731-2:2010. */
|
||||
#ifndef __STDC_WANT_LIB_EXT2__
|
||||
# undef __STDC_WANT_LIB_EXT2__
|
||||
#endif
|
||||
/* Enable extensions specified by ISO/IEC 24747:2009. */
|
||||
#ifndef __STDC_WANT_MATH_SPEC_FUNCS__
|
||||
# undef __STDC_WANT_MATH_SPEC_FUNCS__
|
||||
#endif
|
||||
/* Enable extensions on HP NonStop. */
|
||||
#ifndef _TANDEM_SOURCE
|
||||
# undef _TANDEM_SOURCE
|
||||
#endif
|
||||
/* Enable X/Open extensions. Define to 500 only if necessary
|
||||
to make mbstate_t available. */
|
||||
#ifndef _XOPEN_SOURCE
|
||||
# undef _XOPEN_SOURCE
|
||||
#endif
|
||||
|
||||
|
||||
/* Version number of package */
|
||||
#undef VERSION
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
@ -0,0 +1,247 @@
|
||||
## Process this file with autoconf to produce configure.
|
||||
## In general, the safest way to proceed is to run ./autogen.sh
|
||||
|
||||
AC_PREREQ(2.59)
|
||||
|
||||
# Note: If you change the version, you must also update it in:
|
||||
# * Protobuf.podspec
|
||||
# * csharp/Google.Protobuf.Tools.nuspec
|
||||
# * csharp/src/*/AssemblyInfo.cs
|
||||
# * csharp/src/Google.Protobuf/Google.Protobuf.nuspec
|
||||
# * java/*/pom.xml
|
||||
# * python/google/protobuf/__init__.py
|
||||
# * protoc-artifacts/pom.xml
|
||||
# * src/google/protobuf/stubs/common.h
|
||||
# * src/Makefile.am (Update -version-info for LDFLAGS if needed)
|
||||
#
|
||||
# In the SVN trunk, the version should always be the next anticipated release
|
||||
# version with the "-pre" suffix. (We used to use "-SNAPSHOT" but this pushed
|
||||
# the size of one file name in the dist tarfile over the 99-char limit.)
|
||||
AC_INIT([Protocol Buffers],[3.21.10],[protobuf@googlegroups.com],[protobuf])
|
||||
|
||||
AM_MAINTAINER_MODE([enable])
|
||||
|
||||
AC_CONFIG_SRCDIR(src/google/protobuf/message.cc)
|
||||
# The config file is generated but not used by the source code, since we only
|
||||
# need very few of them, e.g. HAVE_PTHREAD and HAVE_ZLIB. Those macros are
|
||||
# passed down in CXXFLAGS manually in src/Makefile.am
|
||||
AC_CONFIG_HEADERS([config.h])
|
||||
AC_CONFIG_MACRO_DIR([m4])
|
||||
|
||||
AC_ARG_VAR(DIST_LANG, [language to include in the distribution package (i.e., make dist)])
|
||||
case "$DIST_LANG" in
|
||||
"") DIST_LANG=all ;;
|
||||
all | cpp | csharp | java | python | javanano | objectivec | ruby | php) ;;
|
||||
*) AC_MSG_FAILURE([unknown language: $DIST_LANG]) ;;
|
||||
esac
|
||||
AC_SUBST(DIST_LANG)
|
||||
|
||||
# autoconf's default CXXFLAGS are usually "-g -O2". These aren't necessarily
|
||||
# the best choice for libprotobuf.
|
||||
AS_IF([test "x${ac_cv_env_CFLAGS_set}" = "x"],
|
||||
[CFLAGS=""])
|
||||
AS_IF([test "x${ac_cv_env_CXXFLAGS_set}" = "x"],
|
||||
[CXXFLAGS=""])
|
||||
|
||||
AC_CANONICAL_TARGET
|
||||
|
||||
AM_INIT_AUTOMAKE([1.9 tar-ustar subdir-objects])
|
||||
|
||||
# Silent rules enabled: the output is minimal but informative.
|
||||
# In particular, the warnings from the compiler stick out very clearly.
|
||||
# To see all logs, use the --disable-silent-rules on configure or via make V=1
|
||||
AM_SILENT_RULES([yes])
|
||||
|
||||
AC_ARG_WITH([zlib],
|
||||
[AS_HELP_STRING([--with-zlib],
|
||||
[include classes for streaming compressed data in and out @<:@default=check@:>@])],
|
||||
[],[with_zlib=check])
|
||||
|
||||
AC_ARG_WITH([zlib-include],
|
||||
[AS_HELP_STRING([--with-zlib-include=PATH],
|
||||
[zlib include directory])],
|
||||
[CPPFLAGS="-I$withval $CPPFLAGS"])
|
||||
|
||||
AC_ARG_WITH([zlib-lib],
|
||||
[AS_HELP_STRING([--with-zlib-lib=PATH],
|
||||
[zlib lib directory])],
|
||||
[LDFLAGS="-L$withval $LDFLAGS"])
|
||||
|
||||
AC_ARG_WITH([protoc],
|
||||
[AS_HELP_STRING([--with-protoc=COMMAND],
|
||||
[use the given protoc command instead of building a new one when building tests (useful for cross-compiling)])],
|
||||
[],[with_protoc=no])
|
||||
|
||||
# Checks for programs.
|
||||
AC_PROG_CC
|
||||
AC_PROG_CXX
|
||||
AC_PROG_CXX_FOR_BUILD
|
||||
AC_LANG([C++])
|
||||
ACX_USE_SYSTEM_EXTENSIONS
|
||||
m4_ifdef([AM_PROG_AR], [AM_PROG_AR])
|
||||
AM_CONDITIONAL(GCC, test "$GCC" = yes) # let the Makefile know if we're gcc
|
||||
AS_CASE([$target_os], [darwin*], [AC_PROG_OBJC], [AM_CONDITIONAL([am__fastdepOBJC], [false])])
|
||||
|
||||
# test_util.cc takes forever to compile with GCC and optimization turned on.
|
||||
AC_MSG_CHECKING([C++ compiler flags...])
|
||||
AS_IF([test "x${ac_cv_env_CXXFLAGS_set}" = "x"],[
|
||||
AS_IF([test "$GCC" = "yes"],[
|
||||
PROTOBUF_OPT_FLAG="-O2"
|
||||
CXXFLAGS="${CXXFLAGS} -g"
|
||||
])
|
||||
|
||||
# Protocol Buffers contains several checks that are intended to be used only
|
||||
# for debugging and which might hurt performance. Most users are probably
|
||||
# end users who don't want these checks, so add -DNDEBUG by default.
|
||||
CXXFLAGS="$CXXFLAGS -std=c++11 -DNDEBUG"
|
||||
|
||||
AC_MSG_RESULT([use default: $PROTOBUF_OPT_FLAG $CXXFLAGS])
|
||||
],[
|
||||
AC_MSG_RESULT([use user-supplied: $CXXFLAGS])
|
||||
])
|
||||
|
||||
AC_SUBST(PROTOBUF_OPT_FLAG)
|
||||
|
||||
ACX_CHECK_SUNCC
|
||||
|
||||
# Have to do libtool after SUNCC, other wise it "helpfully" adds Crun Cstd
|
||||
# to the link
|
||||
AC_PROG_LIBTOOL
|
||||
|
||||
# Check whether the linker supports version scripts
|
||||
AC_MSG_CHECKING([whether the linker supports version scripts])
|
||||
save_LDFLAGS=$LDFLAGS
|
||||
LDFLAGS="$LDFLAGS -Wl,--version-script=conftest.map"
|
||||
cat > conftest.map <<EOF
|
||||
{
|
||||
global:
|
||||
main;
|
||||
local:
|
||||
*;
|
||||
};
|
||||
EOF
|
||||
AC_LINK_IFELSE(
|
||||
[AC_LANG_SOURCE([int main() { return 0; }])],
|
||||
[have_ld_version_script=yes; AC_MSG_RESULT(yes)],
|
||||
[have_ld_version_script=no; AC_MSG_RESULT(no)])
|
||||
LDFLAGS=$save_LDFLAGS
|
||||
AM_CONDITIONAL([HAVE_LD_VERSION_SCRIPT], [test "$have_ld_version_script" = "yes"])
|
||||
|
||||
# Checks for header files.
|
||||
AC_HEADER_STDC
|
||||
AC_CHECK_HEADERS([fcntl.h inttypes.h limits.h stdlib.h unistd.h])
|
||||
|
||||
# Checks for library functions.
|
||||
AC_FUNC_MEMCMP
|
||||
AC_FUNC_STRTOD
|
||||
AC_CHECK_FUNCS([ftruncate memset mkdir strchr strerror strtol])
|
||||
|
||||
# Check for zlib.
|
||||
HAVE_ZLIB=0
|
||||
AS_IF([test "$with_zlib" != no], [
|
||||
AC_MSG_CHECKING([zlib version])
|
||||
|
||||
# First check the zlib header version.
|
||||
AC_COMPILE_IFELSE(
|
||||
[AC_LANG_PROGRAM([[
|
||||
#include <zlib.h>
|
||||
#if !defined(ZLIB_VERNUM) || (ZLIB_VERNUM < 0x1204)
|
||||
# error zlib version too old
|
||||
#endif
|
||||
]], [])], [
|
||||
AC_MSG_RESULT([ok (1.2.0.4 or later)])
|
||||
|
||||
# Also need to add -lz to the linker flags and make sure this succeeds.
|
||||
AC_SEARCH_LIBS([zlibVersion], [z], [
|
||||
AC_DEFINE([HAVE_ZLIB], [1], [Enable classes using zlib compression.])
|
||||
HAVE_ZLIB=1
|
||||
], [
|
||||
AS_IF([test "$with_zlib" != check], [
|
||||
AC_MSG_FAILURE([--with-zlib was given, but no working zlib library was found])
|
||||
])
|
||||
])
|
||||
], [
|
||||
AS_IF([test "$with_zlib" = check], [
|
||||
AC_MSG_RESULT([headers missing or too old (requires 1.2.0.4)])
|
||||
], [
|
||||
AC_MSG_FAILURE([--with-zlib was given, but zlib headers were not present or were too old (requires 1.2.0.4)])
|
||||
])
|
||||
])
|
||||
])
|
||||
AM_CONDITIONAL([HAVE_ZLIB], [test $HAVE_ZLIB = 1])
|
||||
|
||||
# Add -std=c++11 if necesssary. It is important for us to do this before the
|
||||
# libatomic check below, since that also depends on C++11.
|
||||
AX_CXX_COMPILE_STDCXX([11], [noext], [mandatory])
|
||||
|
||||
dnl On some platforms, std::atomic needs a helper library
|
||||
AC_MSG_CHECKING(whether -latomic is needed)
|
||||
AC_LINK_IFELSE([AC_LANG_SOURCE([[
|
||||
#include <atomic>
|
||||
#include <cstdint>
|
||||
std::atomic<std::int64_t> v;
|
||||
int main() {
|
||||
return v;
|
||||
}
|
||||
]])], STD_ATOMIC_NEED_LIBATOMIC=no, STD_ATOMIC_NEED_LIBATOMIC=yes)
|
||||
AC_MSG_RESULT($STD_ATOMIC_NEED_LIBATOMIC)
|
||||
if test "x$STD_ATOMIC_NEED_LIBATOMIC" = xyes; then
|
||||
LIBATOMIC_LIBS="-latomic"
|
||||
fi
|
||||
AC_SUBST([LIBATOMIC_LIBS])
|
||||
|
||||
AS_IF([test "$with_protoc" != "no"], [
|
||||
PROTOC=$with_protoc
|
||||
AS_IF([test "$with_protoc" = "yes"], [
|
||||
# No argument given. Use system protoc.
|
||||
PROTOC=protoc
|
||||
])
|
||||
AS_IF([echo "$PROTOC" | grep -q '^@<:@^/@:>@.*/'], [
|
||||
# Does not start with a slash, but contains a slash. So, it's a relative
|
||||
# path (as opposed to an absolute path or an executable in $PATH).
|
||||
# Since it will actually be executed from the src directory, prefix with
|
||||
# the current directory. We also insert $ac_top_build_prefix in case this
|
||||
# is a nested package and --with-protoc was actually given on the outer
|
||||
# package's configure script.
|
||||
PROTOC=`pwd`/${ac_top_build_prefix}$PROTOC
|
||||
])
|
||||
AC_SUBST([PROTOC])
|
||||
])
|
||||
AM_CONDITIONAL([USE_EXTERNAL_PROTOC], [test "$with_protoc" != "no"])
|
||||
|
||||
AX_PTHREAD
|
||||
AM_CONDITIONAL([HAVE_PTHREAD], [test "x$ax_pthread_ok" = "xyes"])
|
||||
# We still keep this for improving pbconfig.h for unsupported platforms.
|
||||
AC_CXX_STL_HASH
|
||||
|
||||
# Enable ObjC support for conformance directory on OS X.
|
||||
OBJC_CONFORMANCE_TEST=0
|
||||
case "$target_os" in
|
||||
darwin*)
|
||||
OBJC_CONFORMANCE_TEST=1
|
||||
;;
|
||||
esac
|
||||
AM_CONDITIONAL([OBJC_CONFORMANCE_TEST], [test $OBJC_CONFORMANCE_TEST = 1])
|
||||
|
||||
AC_MSG_CHECKING(whether -llog is needed)
|
||||
ANDROID_TEST=no
|
||||
case "$target_os" in
|
||||
*android*)
|
||||
ANDROID_TEST=yes
|
||||
;;
|
||||
esac
|
||||
AC_MSG_RESULT($ANDROID_TEST)
|
||||
if test "x$ANDROID_TEST" = xyes; then
|
||||
LIBLOG_LIBS="-llog"
|
||||
fi
|
||||
AC_SUBST([LIBLOG_LIBS])
|
||||
|
||||
# HACK: Make gmock's configure script pick up our copy of CFLAGS and CXXFLAGS,
|
||||
# since the flags added by ACX_CHECK_SUNCC must be used when compiling gmock
|
||||
# too.
|
||||
export CFLAGS
|
||||
export CXXFLAGS
|
||||
AC_CONFIG_SUBDIRS([third_party/googletest])
|
||||
|
||||
AC_CONFIG_FILES([Makefile src/Makefile benchmarks/Makefile conformance/Makefile protobuf.pc protobuf-lite.pc])
|
||||
AC_OUTPUT
|
||||
File diff suppressed because it is too large
Load Diff
@ -1,318 +0,0 @@
|
||||
// Protocol Buffers - Google's data interchange format
|
||||
// Copyright 2008 Google Inc. All rights reserved.
|
||||
// http://code.google.com/p/protobuf/
|
||||
//
|
||||
// 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.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// 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.
|
||||
|
||||
// Author: kenton@google.com (Kenton Varda)
|
||||
// Based on original Protocol Buffers design by
|
||||
// Sanjay Ghemawat, Jeff Dean, and others.
|
||||
//
|
||||
// Implements the Protocol Compiler front-end such that it may be reused by
|
||||
// custom compilers written to support other languages.
|
||||
|
||||
#ifndef GOOGLE_PROTOBUF_COMPILER_COMMAND_LINE_INTERFACE_H__
|
||||
#define GOOGLE_PROTOBUF_COMPILER_COMMAND_LINE_INTERFACE_H__
|
||||
|
||||
#include <google/protobuf/stubs/common.h>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
#include <map>
|
||||
#include <set>
|
||||
#include <utility>
|
||||
|
||||
namespace google {
|
||||
namespace protobuf {
|
||||
|
||||
class FileDescriptor; // descriptor.h
|
||||
class DescriptorPool; // descriptor.h
|
||||
class FileDescriptorProto; // descriptor.pb.h
|
||||
template<typename T> class RepeatedPtrField; // repeated_field.h
|
||||
|
||||
namespace compiler {
|
||||
|
||||
class CodeGenerator; // code_generator.h
|
||||
class GeneratorContext; // code_generator.h
|
||||
class DiskSourceTree; // importer.h
|
||||
|
||||
// This class implements the command-line interface to the protocol compiler.
|
||||
// It is designed to make it very easy to create a custom protocol compiler
|
||||
// supporting the languages of your choice. For example, if you wanted to
|
||||
// create a custom protocol compiler binary which includes both the regular
|
||||
// C++ support plus support for your own custom output "Foo", you would
|
||||
// write a class "FooGenerator" which implements the CodeGenerator interface,
|
||||
// then write a main() procedure like this:
|
||||
//
|
||||
// int main(int argc, char* argv[]) {
|
||||
// google::protobuf::compiler::CommandLineInterface cli;
|
||||
//
|
||||
// // Support generation of C++ source and headers.
|
||||
// google::protobuf::compiler::cpp::CppGenerator cpp_generator;
|
||||
// cli.RegisterGenerator("--cpp_out", &cpp_generator,
|
||||
// "Generate C++ source and header.");
|
||||
//
|
||||
// // Support generation of Foo code.
|
||||
// FooGenerator foo_generator;
|
||||
// cli.RegisterGenerator("--foo_out", &foo_generator,
|
||||
// "Generate Foo file.");
|
||||
//
|
||||
// return cli.Run(argc, argv);
|
||||
// }
|
||||
//
|
||||
// The compiler is invoked with syntax like:
|
||||
// protoc --cpp_out=outdir --foo_out=outdir --proto_path=src src/foo.proto
|
||||
//
|
||||
// For a full description of the command-line syntax, invoke it with --help.
|
||||
class LIBPROTOC_EXPORT CommandLineInterface {
|
||||
public:
|
||||
CommandLineInterface();
|
||||
~CommandLineInterface();
|
||||
|
||||
// Register a code generator for a language.
|
||||
//
|
||||
// Parameters:
|
||||
// * flag_name: The command-line flag used to specify an output file of
|
||||
// this type. The name must start with a '-'. If the name is longer
|
||||
// than one letter, it must start with two '-'s.
|
||||
// * generator: The CodeGenerator which will be called to generate files
|
||||
// of this type.
|
||||
// * help_text: Text describing this flag in the --help output.
|
||||
//
|
||||
// Some generators accept extra parameters. You can specify this parameter
|
||||
// on the command-line by placing it before the output directory, separated
|
||||
// by a colon:
|
||||
// protoc --foo_out=enable_bar:outdir
|
||||
// The text before the colon is passed to CodeGenerator::Generate() as the
|
||||
// "parameter".
|
||||
void RegisterGenerator(const string& flag_name,
|
||||
CodeGenerator* generator,
|
||||
const string& help_text);
|
||||
|
||||
// Enables "plugins". In this mode, if a command-line flag ends with "_out"
|
||||
// but does not match any registered generator, the compiler will attempt to
|
||||
// find a "plugin" to implement the generator. Plugins are just executables.
|
||||
// They should live somewhere in the PATH.
|
||||
//
|
||||
// The compiler determines the executable name to search for by concatenating
|
||||
// exe_name_prefix with the unrecognized flag name, removing "_out". So, for
|
||||
// example, if exe_name_prefix is "protoc-" and you pass the flag --foo_out,
|
||||
// the compiler will try to run the program "protoc-foo".
|
||||
//
|
||||
// The plugin program should implement the following usage:
|
||||
// plugin [--out=OUTDIR] [--parameter=PARAMETER] PROTO_FILES < DESCRIPTORS
|
||||
// --out indicates the output directory (as passed to the --foo_out
|
||||
// parameter); if omitted, the current directory should be used. --parameter
|
||||
// gives the generator parameter, if any was provided. The PROTO_FILES list
|
||||
// the .proto files which were given on the compiler command-line; these are
|
||||
// the files for which the plugin is expected to generate output code.
|
||||
// Finally, DESCRIPTORS is an encoded FileDescriptorSet (as defined in
|
||||
// descriptor.proto). This is piped to the plugin's stdin. The set will
|
||||
// include descriptors for all the files listed in PROTO_FILES as well as
|
||||
// all files that they import. The plugin MUST NOT attempt to read the
|
||||
// PROTO_FILES directly -- it must use the FileDescriptorSet.
|
||||
//
|
||||
// The plugin should generate whatever files are necessary, as code generators
|
||||
// normally do. It should write the names of all files it generates to
|
||||
// stdout. The names should be relative to the output directory, NOT absolute
|
||||
// names or relative to the current directory. If any errors occur, error
|
||||
// messages should be written to stderr. If an error is fatal, the plugin
|
||||
// should exit with a non-zero exit code.
|
||||
void AllowPlugins(const string& exe_name_prefix);
|
||||
|
||||
// Run the Protocol Compiler with the given command-line parameters.
|
||||
// Returns the error code which should be returned by main().
|
||||
//
|
||||
// It may not be safe to call Run() in a multi-threaded environment because
|
||||
// it calls strerror(). I'm not sure why you'd want to do this anyway.
|
||||
int Run(int argc, const char* const argv[]);
|
||||
|
||||
// Call SetInputsAreCwdRelative(true) if the input files given on the command
|
||||
// line should be interpreted relative to the proto import path specified
|
||||
// using --proto_path or -I flags. Otherwise, input file names will be
|
||||
// interpreted relative to the current working directory (or as absolute
|
||||
// paths if they start with '/'), though they must still reside inside
|
||||
// a directory given by --proto_path or the compiler will fail. The latter
|
||||
// mode is generally more intuitive and easier to use, especially e.g. when
|
||||
// defining implicit rules in Makefiles.
|
||||
void SetInputsAreProtoPathRelative(bool enable) {
|
||||
inputs_are_proto_path_relative_ = enable;
|
||||
}
|
||||
|
||||
// Provides some text which will be printed when the --version flag is
|
||||
// used. The version of libprotoc will also be printed on the next line
|
||||
// after this text.
|
||||
void SetVersionInfo(const string& text) {
|
||||
version_info_ = text;
|
||||
}
|
||||
|
||||
|
||||
private:
|
||||
// -----------------------------------------------------------------
|
||||
|
||||
class ErrorPrinter;
|
||||
class GeneratorContextImpl;
|
||||
class MemoryOutputStream;
|
||||
|
||||
// Clear state from previous Run().
|
||||
void Clear();
|
||||
|
||||
// Remaps each file in input_files_ so that it is relative to one of the
|
||||
// directories in proto_path_. Returns false if an error occurred. This
|
||||
// is only used if inputs_are_proto_path_relative_ is false.
|
||||
bool MakeInputsBeProtoPathRelative(
|
||||
DiskSourceTree* source_tree);
|
||||
|
||||
// Parse all command-line arguments.
|
||||
bool ParseArguments(int argc, const char* const argv[]);
|
||||
|
||||
// Parses a command-line argument into a name/value pair. Returns
|
||||
// true if the next argument in the argv should be used as the value,
|
||||
// false otherwise.
|
||||
//
|
||||
// Exmaples:
|
||||
// "-Isrc/protos" ->
|
||||
// name = "-I", value = "src/protos"
|
||||
// "--cpp_out=src/foo.pb2.cc" ->
|
||||
// name = "--cpp_out", value = "src/foo.pb2.cc"
|
||||
// "foo.proto" ->
|
||||
// name = "", value = "foo.proto"
|
||||
bool ParseArgument(const char* arg, string* name, string* value);
|
||||
|
||||
// Interprets arguments parsed with ParseArgument.
|
||||
bool InterpretArgument(const string& name, const string& value);
|
||||
|
||||
// Print the --help text to stderr.
|
||||
void PrintHelpText();
|
||||
|
||||
// Generate the given output file from the given input.
|
||||
struct OutputDirective; // see below
|
||||
bool GenerateOutput(const vector<const FileDescriptor*>& parsed_files,
|
||||
const OutputDirective& output_directive,
|
||||
GeneratorContext* generator_context);
|
||||
bool GeneratePluginOutput(const vector<const FileDescriptor*>& parsed_files,
|
||||
const string& plugin_name,
|
||||
const string& parameter,
|
||||
GeneratorContext* generator_context,
|
||||
string* error);
|
||||
|
||||
// Implements --encode and --decode.
|
||||
bool EncodeOrDecode(const DescriptorPool* pool);
|
||||
|
||||
// Implements the --descriptor_set_out option.
|
||||
bool WriteDescriptorSet(const vector<const FileDescriptor*> parsed_files);
|
||||
|
||||
// Get all transitive dependencies of the given file (including the file
|
||||
// itself), adding them to the given list of FileDescriptorProtos. The
|
||||
// protos will be ordered such that every file is listed before any file that
|
||||
// depends on it, so that you can call DescriptorPool::BuildFile() on them
|
||||
// in order. Any files in *already_seen will not be added, and each file
|
||||
// added will be inserted into *already_seen.
|
||||
static void GetTransitiveDependencies(
|
||||
const FileDescriptor* file,
|
||||
set<const FileDescriptor*>* already_seen,
|
||||
RepeatedPtrField<FileDescriptorProto>* output);
|
||||
|
||||
// -----------------------------------------------------------------
|
||||
|
||||
// The name of the executable as invoked (i.e. argv[0]).
|
||||
string executable_name_;
|
||||
|
||||
// Version info set with SetVersionInfo().
|
||||
string version_info_;
|
||||
|
||||
// Map from flag names to registered generators.
|
||||
struct GeneratorInfo {
|
||||
CodeGenerator* generator;
|
||||
string help_text;
|
||||
};
|
||||
typedef map<string, GeneratorInfo> GeneratorMap;
|
||||
GeneratorMap generators_;
|
||||
|
||||
// See AllowPlugins(). If this is empty, plugins aren't allowed.
|
||||
string plugin_prefix_;
|
||||
|
||||
// Maps specific plugin names to files. When executing a plugin, this map
|
||||
// is searched first to find the plugin executable. If not found here, the
|
||||
// PATH (or other OS-specific search strategy) is searched.
|
||||
map<string, string> plugins_;
|
||||
|
||||
// Stuff parsed from command line.
|
||||
enum Mode {
|
||||
MODE_COMPILE, // Normal mode: parse .proto files and compile them.
|
||||
MODE_ENCODE, // --encode: read text from stdin, write binary to stdout.
|
||||
MODE_DECODE // --decode: read binary from stdin, write text to stdout.
|
||||
};
|
||||
|
||||
Mode mode_;
|
||||
|
||||
enum ErrorFormat {
|
||||
ERROR_FORMAT_GCC, // GCC error output format (default).
|
||||
ERROR_FORMAT_MSVS // Visual Studio output (--error_format=msvs).
|
||||
};
|
||||
|
||||
ErrorFormat error_format_;
|
||||
|
||||
vector<pair<string, string> > proto_path_; // Search path for proto files.
|
||||
vector<string> input_files_; // Names of the input proto files.
|
||||
|
||||
// output_directives_ lists all the files we are supposed to output and what
|
||||
// generator to use for each.
|
||||
struct OutputDirective {
|
||||
string name; // E.g. "--foo_out"
|
||||
CodeGenerator* generator; // NULL for plugins
|
||||
string parameter;
|
||||
string output_location;
|
||||
};
|
||||
vector<OutputDirective> output_directives_;
|
||||
|
||||
// When using --encode or --decode, this names the type we are encoding or
|
||||
// decoding. (Empty string indicates --decode_raw.)
|
||||
string codec_type_;
|
||||
|
||||
// If --descriptor_set_out was given, this is the filename to which the
|
||||
// FileDescriptorSet should be written. Otherwise, empty.
|
||||
string descriptor_set_name_;
|
||||
|
||||
// True if --include_imports was given, meaning that we should
|
||||
// write all transitive dependencies to the DescriptorSet. Otherwise, only
|
||||
// the .proto files listed on the command-line are added.
|
||||
bool imports_in_descriptor_set_;
|
||||
|
||||
// Was the --disallow_services flag used?
|
||||
bool disallow_services_;
|
||||
|
||||
// See SetInputsAreProtoPathRelative().
|
||||
bool inputs_are_proto_path_relative_;
|
||||
|
||||
GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(CommandLineInterface);
|
||||
};
|
||||
|
||||
} // namespace compiler
|
||||
} // namespace protobuf
|
||||
|
||||
} // namespace google
|
||||
#endif // GOOGLE_PROTOBUF_COMPILER_COMMAND_LINE_INTERFACE_H__
|
||||
@ -1,258 +0,0 @@
|
||||
// Protocol Buffers - Google's data interchange format
|
||||
// Copyright 2008 Google Inc. All rights reserved.
|
||||
// http://code.google.com/p/protobuf/
|
||||
//
|
||||
// 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.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// 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.
|
||||
|
||||
// Author: kenton@google.com (Kenton Varda)
|
||||
// Based on original Protocol Buffers design by
|
||||
// Sanjay Ghemawat, Jeff Dean, and others.
|
||||
|
||||
#include <set>
|
||||
#include <map>
|
||||
|
||||
#include <google/protobuf/compiler/cpp/cpp_enum.h>
|
||||
#include <google/protobuf/compiler/cpp/cpp_helpers.h>
|
||||
#include <google/protobuf/io/printer.h>
|
||||
#include <google/protobuf/stubs/strutil.h>
|
||||
|
||||
namespace google {
|
||||
namespace protobuf {
|
||||
namespace compiler {
|
||||
namespace cpp {
|
||||
|
||||
EnumGenerator::EnumGenerator(const EnumDescriptor* descriptor,
|
||||
const string& dllexport_decl)
|
||||
: descriptor_(descriptor),
|
||||
classname_(ClassName(descriptor, false)),
|
||||
dllexport_decl_(dllexport_decl) {
|
||||
}
|
||||
|
||||
EnumGenerator::~EnumGenerator() {}
|
||||
|
||||
void EnumGenerator::GenerateDefinition(io::Printer* printer) {
|
||||
map<string, string> vars;
|
||||
vars["classname"] = classname_;
|
||||
vars["short_name"] = descriptor_->name();
|
||||
|
||||
printer->Print(vars, "enum $classname$ {\n");
|
||||
printer->Indent();
|
||||
|
||||
const EnumValueDescriptor* min_value = descriptor_->value(0);
|
||||
const EnumValueDescriptor* max_value = descriptor_->value(0);
|
||||
|
||||
for (int i = 0; i < descriptor_->value_count(); i++) {
|
||||
vars["name"] = descriptor_->value(i)->name();
|
||||
vars["number"] = SimpleItoa(descriptor_->value(i)->number());
|
||||
vars["prefix"] = (descriptor_->containing_type() == NULL) ?
|
||||
"" : classname_ + "_";
|
||||
|
||||
if (i > 0) printer->Print(",\n");
|
||||
printer->Print(vars, "$prefix$$name$ = $number$");
|
||||
|
||||
if (descriptor_->value(i)->number() < min_value->number()) {
|
||||
min_value = descriptor_->value(i);
|
||||
}
|
||||
if (descriptor_->value(i)->number() > max_value->number()) {
|
||||
max_value = descriptor_->value(i);
|
||||
}
|
||||
}
|
||||
|
||||
printer->Outdent();
|
||||
printer->Print("\n};\n");
|
||||
|
||||
vars["min_name"] = min_value->name();
|
||||
vars["max_name"] = max_value->name();
|
||||
|
||||
if (dllexport_decl_.empty()) {
|
||||
vars["dllexport"] = "";
|
||||
} else {
|
||||
vars["dllexport"] = dllexport_decl_ + " ";
|
||||
}
|
||||
|
||||
printer->Print(vars,
|
||||
"$dllexport$bool $classname$_IsValid(int value);\n"
|
||||
"const $classname$ $prefix$$short_name$_MIN = $prefix$$min_name$;\n"
|
||||
"const $classname$ $prefix$$short_name$_MAX = $prefix$$max_name$;\n"
|
||||
"const int $prefix$$short_name$_ARRAYSIZE = $prefix$$short_name$_MAX + 1;\n"
|
||||
"\n");
|
||||
|
||||
if (HasDescriptorMethods(descriptor_->file())) {
|
||||
printer->Print(vars,
|
||||
"$dllexport$const ::google::protobuf::EnumDescriptor* $classname$_descriptor();\n");
|
||||
// The _Name and _Parse methods
|
||||
printer->Print(vars,
|
||||
"inline const ::std::string& $classname$_Name($classname$ value) {\n"
|
||||
" return ::google::protobuf::internal::NameOfEnum(\n"
|
||||
" $classname$_descriptor(), value);\n"
|
||||
"}\n");
|
||||
printer->Print(vars,
|
||||
"inline bool $classname$_Parse(\n"
|
||||
" const ::std::string& name, $classname$* value) {\n"
|
||||
" return ::google::protobuf::internal::ParseNamedEnum<$classname$>(\n"
|
||||
" $classname$_descriptor(), name, value);\n"
|
||||
"}\n");
|
||||
}
|
||||
}
|
||||
|
||||
void EnumGenerator::
|
||||
GenerateGetEnumDescriptorSpecializations(io::Printer* printer) {
|
||||
if (HasDescriptorMethods(descriptor_->file())) {
|
||||
printer->Print(
|
||||
"template <>\n"
|
||||
"inline const EnumDescriptor* GetEnumDescriptor< $classname$>() {\n"
|
||||
" return $classname$_descriptor();\n"
|
||||
"}\n",
|
||||
"classname", ClassName(descriptor_, true));
|
||||
}
|
||||
}
|
||||
|
||||
void EnumGenerator::GenerateSymbolImports(io::Printer* printer) {
|
||||
map<string, string> vars;
|
||||
vars["nested_name"] = descriptor_->name();
|
||||
vars["classname"] = classname_;
|
||||
printer->Print(vars, "typedef $classname$ $nested_name$;\n");
|
||||
|
||||
for (int j = 0; j < descriptor_->value_count(); j++) {
|
||||
vars["tag"] = descriptor_->value(j)->name();
|
||||
printer->Print(vars,
|
||||
"static const $nested_name$ $tag$ = $classname$_$tag$;\n");
|
||||
}
|
||||
|
||||
printer->Print(vars,
|
||||
"static inline bool $nested_name$_IsValid(int value) {\n"
|
||||
" return $classname$_IsValid(value);\n"
|
||||
"}\n"
|
||||
"static const $nested_name$ $nested_name$_MIN =\n"
|
||||
" $classname$_$nested_name$_MIN;\n"
|
||||
"static const $nested_name$ $nested_name$_MAX =\n"
|
||||
" $classname$_$nested_name$_MAX;\n"
|
||||
"static const int $nested_name$_ARRAYSIZE =\n"
|
||||
" $classname$_$nested_name$_ARRAYSIZE;\n");
|
||||
|
||||
if (HasDescriptorMethods(descriptor_->file())) {
|
||||
printer->Print(vars,
|
||||
"static inline const ::google::protobuf::EnumDescriptor*\n"
|
||||
"$nested_name$_descriptor() {\n"
|
||||
" return $classname$_descriptor();\n"
|
||||
"}\n");
|
||||
printer->Print(vars,
|
||||
"static inline const ::std::string& $nested_name$_Name($nested_name$ value) {\n"
|
||||
" return $classname$_Name(value);\n"
|
||||
"}\n");
|
||||
printer->Print(vars,
|
||||
"static inline bool $nested_name$_Parse(const ::std::string& name,\n"
|
||||
" $nested_name$* value) {\n"
|
||||
" return $classname$_Parse(name, value);\n"
|
||||
"}\n");
|
||||
}
|
||||
}
|
||||
|
||||
void EnumGenerator::GenerateDescriptorInitializer(
|
||||
io::Printer* printer, int index) {
|
||||
map<string, string> vars;
|
||||
vars["classname"] = classname_;
|
||||
vars["index"] = SimpleItoa(index);
|
||||
|
||||
if (descriptor_->containing_type() == NULL) {
|
||||
printer->Print(vars,
|
||||
"$classname$_descriptor_ = file->enum_type($index$);\n");
|
||||
} else {
|
||||
vars["parent"] = ClassName(descriptor_->containing_type(), false);
|
||||
printer->Print(vars,
|
||||
"$classname$_descriptor_ = $parent$_descriptor_->enum_type($index$);\n");
|
||||
}
|
||||
}
|
||||
|
||||
void EnumGenerator::GenerateMethods(io::Printer* printer) {
|
||||
map<string, string> vars;
|
||||
vars["classname"] = classname_;
|
||||
|
||||
if (HasDescriptorMethods(descriptor_->file())) {
|
||||
printer->Print(vars,
|
||||
"const ::google::protobuf::EnumDescriptor* $classname$_descriptor() {\n"
|
||||
" protobuf_AssignDescriptorsOnce();\n"
|
||||
" return $classname$_descriptor_;\n"
|
||||
"}\n");
|
||||
}
|
||||
|
||||
printer->Print(vars,
|
||||
"bool $classname$_IsValid(int value) {\n"
|
||||
" switch(value) {\n");
|
||||
|
||||
// Multiple values may have the same number. Make sure we only cover
|
||||
// each number once by first constructing a set containing all valid
|
||||
// numbers, then printing a case statement for each element.
|
||||
|
||||
set<int> numbers;
|
||||
for (int j = 0; j < descriptor_->value_count(); j++) {
|
||||
const EnumValueDescriptor* value = descriptor_->value(j);
|
||||
numbers.insert(value->number());
|
||||
}
|
||||
|
||||
for (set<int>::iterator iter = numbers.begin();
|
||||
iter != numbers.end(); ++iter) {
|
||||
printer->Print(
|
||||
" case $number$:\n",
|
||||
"number", SimpleItoa(*iter));
|
||||
}
|
||||
|
||||
printer->Print(vars,
|
||||
" return true;\n"
|
||||
" default:\n"
|
||||
" return false;\n"
|
||||
" }\n"
|
||||
"}\n"
|
||||
"\n");
|
||||
|
||||
if (descriptor_->containing_type() != NULL) {
|
||||
// We need to "define" the static constants which were declared in the
|
||||
// header, to give the linker a place to put them. Or at least the C++
|
||||
// standard says we have to. MSVC actually insists tha we do _not_ define
|
||||
// them again in the .cc file.
|
||||
printer->Print("#ifndef _MSC_VER\n");
|
||||
|
||||
vars["parent"] = ClassName(descriptor_->containing_type(), false);
|
||||
vars["nested_name"] = descriptor_->name();
|
||||
for (int i = 0; i < descriptor_->value_count(); i++) {
|
||||
vars["value"] = descriptor_->value(i)->name();
|
||||
printer->Print(vars,
|
||||
"const $classname$ $parent$::$value$;\n");
|
||||
}
|
||||
printer->Print(vars,
|
||||
"const $classname$ $parent$::$nested_name$_MIN;\n"
|
||||
"const $classname$ $parent$::$nested_name$_MAX;\n"
|
||||
"const int $parent$::$nested_name$_ARRAYSIZE;\n");
|
||||
|
||||
printer->Print("#endif // _MSC_VER\n");
|
||||
}
|
||||
}
|
||||
|
||||
} // namespace cpp
|
||||
} // namespace compiler
|
||||
} // namespace protobuf
|
||||
} // namespace google
|
||||
@ -1,361 +0,0 @@
|
||||
// Protocol Buffers - Google's data interchange format
|
||||
// Copyright 2008 Google Inc. All rights reserved.
|
||||
// http://code.google.com/p/protobuf/
|
||||
//
|
||||
// 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.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// 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.
|
||||
|
||||
// Author: kenton@google.com (Kenton Varda)
|
||||
// Based on original Protocol Buffers design by
|
||||
// Sanjay Ghemawat, Jeff Dean, and others.
|
||||
|
||||
#include <google/protobuf/compiler/cpp/cpp_enum_field.h>
|
||||
#include <google/protobuf/compiler/cpp/cpp_helpers.h>
|
||||
#include <google/protobuf/io/printer.h>
|
||||
#include <google/protobuf/descriptor.pb.h>
|
||||
#include <google/protobuf/stubs/strutil.h>
|
||||
|
||||
namespace google {
|
||||
namespace protobuf {
|
||||
namespace compiler {
|
||||
namespace cpp {
|
||||
|
||||
namespace {
|
||||
|
||||
void SetEnumVariables(const FieldDescriptor* descriptor,
|
||||
map<string, string>* variables) {
|
||||
SetCommonFieldVariables(descriptor, variables);
|
||||
const EnumValueDescriptor* default_value = descriptor->default_value_enum();
|
||||
(*variables)["type"] = ClassName(descriptor->enum_type(), true);
|
||||
(*variables)["default"] = SimpleItoa(default_value->number());
|
||||
}
|
||||
|
||||
} // namespace
|
||||
|
||||
// ===================================================================
|
||||
|
||||
EnumFieldGenerator::
|
||||
EnumFieldGenerator(const FieldDescriptor* descriptor)
|
||||
: descriptor_(descriptor) {
|
||||
SetEnumVariables(descriptor, &variables_);
|
||||
}
|
||||
|
||||
EnumFieldGenerator::~EnumFieldGenerator() {}
|
||||
|
||||
void EnumFieldGenerator::
|
||||
GeneratePrivateMembers(io::Printer* printer) const {
|
||||
printer->Print(variables_, "int $name$_;\n");
|
||||
}
|
||||
|
||||
void EnumFieldGenerator::
|
||||
GenerateAccessorDeclarations(io::Printer* printer) const {
|
||||
printer->Print(variables_,
|
||||
"inline $type$ $name$() const$deprecation$;\n"
|
||||
"inline void set_$name$($type$ value)$deprecation$;\n");
|
||||
}
|
||||
|
||||
void EnumFieldGenerator::
|
||||
GenerateInlineAccessorDefinitions(io::Printer* printer) const {
|
||||
printer->Print(variables_,
|
||||
"inline $type$ $classname$::$name$() const {\n"
|
||||
" return static_cast< $type$ >($name$_);\n"
|
||||
"}\n"
|
||||
"inline void $classname$::set_$name$($type$ value) {\n"
|
||||
" GOOGLE_DCHECK($type$_IsValid(value));\n"
|
||||
" set_has_$name$();\n"
|
||||
" $name$_ = value;\n"
|
||||
"}\n");
|
||||
}
|
||||
|
||||
void EnumFieldGenerator::
|
||||
GenerateClearingCode(io::Printer* printer) const {
|
||||
printer->Print(variables_, "$name$_ = $default$;\n");
|
||||
}
|
||||
|
||||
void EnumFieldGenerator::
|
||||
GenerateMergingCode(io::Printer* printer) const {
|
||||
printer->Print(variables_, "set_$name$(from.$name$());\n");
|
||||
}
|
||||
|
||||
void EnumFieldGenerator::
|
||||
GenerateSwappingCode(io::Printer* printer) const {
|
||||
printer->Print(variables_, "std::swap($name$_, other->$name$_);\n");
|
||||
}
|
||||
|
||||
void EnumFieldGenerator::
|
||||
GenerateConstructorCode(io::Printer* printer) const {
|
||||
printer->Print(variables_, "$name$_ = $default$;\n");
|
||||
}
|
||||
|
||||
void EnumFieldGenerator::
|
||||
GenerateMergeFromCodedStream(io::Printer* printer) const {
|
||||
printer->Print(variables_,
|
||||
"int value;\n"
|
||||
"DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<\n"
|
||||
" int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(\n"
|
||||
" input, &value)));\n"
|
||||
"if ($type$_IsValid(value)) {\n"
|
||||
" set_$name$(static_cast< $type$ >(value));\n");
|
||||
if (HasUnknownFields(descriptor_->file())) {
|
||||
printer->Print(variables_,
|
||||
"} else {\n"
|
||||
" mutable_unknown_fields()->AddVarint($number$, value);\n");
|
||||
}
|
||||
printer->Print(variables_,
|
||||
"}\n");
|
||||
}
|
||||
|
||||
void EnumFieldGenerator::
|
||||
GenerateSerializeWithCachedSizes(io::Printer* printer) const {
|
||||
printer->Print(variables_,
|
||||
"::google::protobuf::internal::WireFormatLite::WriteEnum(\n"
|
||||
" $number$, this->$name$(), output);\n");
|
||||
}
|
||||
|
||||
void EnumFieldGenerator::
|
||||
GenerateSerializeWithCachedSizesToArray(io::Printer* printer) const {
|
||||
printer->Print(variables_,
|
||||
"target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(\n"
|
||||
" $number$, this->$name$(), target);\n");
|
||||
}
|
||||
|
||||
void EnumFieldGenerator::
|
||||
GenerateByteSize(io::Printer* printer) const {
|
||||
printer->Print(variables_,
|
||||
"total_size += $tag_size$ +\n"
|
||||
" ::google::protobuf::internal::WireFormatLite::EnumSize(this->$name$());\n");
|
||||
}
|
||||
|
||||
// ===================================================================
|
||||
|
||||
RepeatedEnumFieldGenerator::
|
||||
RepeatedEnumFieldGenerator(const FieldDescriptor* descriptor)
|
||||
: descriptor_(descriptor) {
|
||||
SetEnumVariables(descriptor, &variables_);
|
||||
}
|
||||
|
||||
RepeatedEnumFieldGenerator::~RepeatedEnumFieldGenerator() {}
|
||||
|
||||
void RepeatedEnumFieldGenerator::
|
||||
GeneratePrivateMembers(io::Printer* printer) const {
|
||||
printer->Print(variables_,
|
||||
"::google::protobuf::RepeatedField<int> $name$_;\n");
|
||||
if (descriptor_->options().packed() && HasGeneratedMethods(descriptor_->file())) {
|
||||
printer->Print(variables_,
|
||||
"mutable int _$name$_cached_byte_size_;\n");
|
||||
}
|
||||
}
|
||||
|
||||
void RepeatedEnumFieldGenerator::
|
||||
GenerateAccessorDeclarations(io::Printer* printer) const {
|
||||
printer->Print(variables_,
|
||||
"inline $type$ $name$(int index) const$deprecation$;\n"
|
||||
"inline void set_$name$(int index, $type$ value)$deprecation$;\n"
|
||||
"inline void add_$name$($type$ value)$deprecation$;\n");
|
||||
printer->Print(variables_,
|
||||
"inline const ::google::protobuf::RepeatedField<int>& $name$() const$deprecation$;\n"
|
||||
"inline ::google::protobuf::RepeatedField<int>* mutable_$name$()$deprecation$;\n");
|
||||
}
|
||||
|
||||
void RepeatedEnumFieldGenerator::
|
||||
GenerateInlineAccessorDefinitions(io::Printer* printer) const {
|
||||
printer->Print(variables_,
|
||||
"inline $type$ $classname$::$name$(int index) const {\n"
|
||||
" return static_cast< $type$ >($name$_.Get(index));\n"
|
||||
"}\n"
|
||||
"inline void $classname$::set_$name$(int index, $type$ value) {\n"
|
||||
" GOOGLE_DCHECK($type$_IsValid(value));\n"
|
||||
" $name$_.Set(index, value);\n"
|
||||
"}\n"
|
||||
"inline void $classname$::add_$name$($type$ value) {\n"
|
||||
" GOOGLE_DCHECK($type$_IsValid(value));\n"
|
||||
" $name$_.Add(value);\n"
|
||||
"}\n");
|
||||
printer->Print(variables_,
|
||||
"inline const ::google::protobuf::RepeatedField<int>&\n"
|
||||
"$classname$::$name$() const {\n"
|
||||
" return $name$_;\n"
|
||||
"}\n"
|
||||
"inline ::google::protobuf::RepeatedField<int>*\n"
|
||||
"$classname$::mutable_$name$() {\n"
|
||||
" return &$name$_;\n"
|
||||
"}\n");
|
||||
}
|
||||
|
||||
void RepeatedEnumFieldGenerator::
|
||||
GenerateClearingCode(io::Printer* printer) const {
|
||||
printer->Print(variables_, "$name$_.Clear();\n");
|
||||
}
|
||||
|
||||
void RepeatedEnumFieldGenerator::
|
||||
GenerateMergingCode(io::Printer* printer) const {
|
||||
printer->Print(variables_, "$name$_.MergeFrom(from.$name$_);\n");
|
||||
}
|
||||
|
||||
void RepeatedEnumFieldGenerator::
|
||||
GenerateSwappingCode(io::Printer* printer) const {
|
||||
printer->Print(variables_, "$name$_.Swap(&other->$name$_);\n");
|
||||
}
|
||||
|
||||
void RepeatedEnumFieldGenerator::
|
||||
GenerateConstructorCode(io::Printer* printer) const {
|
||||
// Not needed for repeated fields.
|
||||
}
|
||||
|
||||
void RepeatedEnumFieldGenerator::
|
||||
GenerateMergeFromCodedStream(io::Printer* printer) const {
|
||||
// Don't use ReadRepeatedPrimitive here so that the enum can be validated.
|
||||
printer->Print(variables_,
|
||||
"int value;\n"
|
||||
"DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<\n"
|
||||
" int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(\n"
|
||||
" input, &value)));\n"
|
||||
"if ($type$_IsValid(value)) {\n"
|
||||
" add_$name$(static_cast< $type$ >(value));\n");
|
||||
if (HasUnknownFields(descriptor_->file())) {
|
||||
printer->Print(variables_,
|
||||
"} else {\n"
|
||||
" mutable_unknown_fields()->AddVarint($number$, value);\n");
|
||||
}
|
||||
printer->Print("}\n");
|
||||
}
|
||||
|
||||
void RepeatedEnumFieldGenerator::
|
||||
GenerateMergeFromCodedStreamWithPacking(io::Printer* printer) const {
|
||||
if (!descriptor_->options().packed()) {
|
||||
// We use a non-inlined implementation in this case, since this path will
|
||||
// rarely be executed.
|
||||
printer->Print(variables_,
|
||||
"DO_((::google::protobuf::internal::WireFormatLite::ReadPackedEnumNoInline(\n"
|
||||
" input,\n"
|
||||
" &$type$_IsValid,\n"
|
||||
" this->mutable_$name$())));\n");
|
||||
} else {
|
||||
printer->Print(variables_,
|
||||
"::google::protobuf::uint32 length;\n"
|
||||
"DO_(input->ReadVarint32(&length));\n"
|
||||
"::google::protobuf::io::CodedInputStream::Limit limit = "
|
||||
"input->PushLimit(length);\n"
|
||||
"while (input->BytesUntilLimit() > 0) {\n"
|
||||
" int value;\n"
|
||||
" DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<\n"
|
||||
" int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(\n"
|
||||
" input, &value)));\n"
|
||||
" if ($type$_IsValid(value)) {\n"
|
||||
" add_$name$(static_cast< $type$ >(value));\n"
|
||||
" }\n"
|
||||
"}\n"
|
||||
"input->PopLimit(limit);\n");
|
||||
}
|
||||
}
|
||||
|
||||
void RepeatedEnumFieldGenerator::
|
||||
GenerateSerializeWithCachedSizes(io::Printer* printer) const {
|
||||
if (descriptor_->options().packed()) {
|
||||
// Write the tag and the size.
|
||||
printer->Print(variables_,
|
||||
"if (this->$name$_size() > 0) {\n"
|
||||
" ::google::protobuf::internal::WireFormatLite::WriteTag(\n"
|
||||
" $number$,\n"
|
||||
" ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED,\n"
|
||||
" output);\n"
|
||||
" output->WriteVarint32(_$name$_cached_byte_size_);\n"
|
||||
"}\n");
|
||||
}
|
||||
printer->Print(variables_,
|
||||
"for (int i = 0; i < this->$name$_size(); i++) {\n");
|
||||
if (descriptor_->options().packed()) {
|
||||
printer->Print(variables_,
|
||||
" ::google::protobuf::internal::WireFormatLite::WriteEnumNoTag(\n"
|
||||
" this->$name$(i), output);\n");
|
||||
} else {
|
||||
printer->Print(variables_,
|
||||
" ::google::protobuf::internal::WireFormatLite::WriteEnum(\n"
|
||||
" $number$, this->$name$(i), output);\n");
|
||||
}
|
||||
printer->Print("}\n");
|
||||
}
|
||||
|
||||
void RepeatedEnumFieldGenerator::
|
||||
GenerateSerializeWithCachedSizesToArray(io::Printer* printer) const {
|
||||
if (descriptor_->options().packed()) {
|
||||
// Write the tag and the size.
|
||||
printer->Print(variables_,
|
||||
"if (this->$name$_size() > 0) {\n"
|
||||
" target = ::google::protobuf::internal::WireFormatLite::WriteTagToArray(\n"
|
||||
" $number$,\n"
|
||||
" ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED,\n"
|
||||
" target);\n"
|
||||
" target = ::google::protobuf::io::CodedOutputStream::WriteVarint32ToArray("
|
||||
" _$name$_cached_byte_size_, target);\n"
|
||||
"}\n");
|
||||
}
|
||||
printer->Print(variables_,
|
||||
"for (int i = 0; i < this->$name$_size(); i++) {\n");
|
||||
if (descriptor_->options().packed()) {
|
||||
printer->Print(variables_,
|
||||
" target = ::google::protobuf::internal::WireFormatLite::WriteEnumNoTagToArray(\n"
|
||||
" this->$name$(i), target);\n");
|
||||
} else {
|
||||
printer->Print(variables_,
|
||||
" target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(\n"
|
||||
" $number$, this->$name$(i), target);\n");
|
||||
}
|
||||
printer->Print("}\n");
|
||||
}
|
||||
|
||||
void RepeatedEnumFieldGenerator::
|
||||
GenerateByteSize(io::Printer* printer) const {
|
||||
printer->Print(variables_,
|
||||
"{\n"
|
||||
" int data_size = 0;\n");
|
||||
printer->Indent();
|
||||
printer->Print(variables_,
|
||||
"for (int i = 0; i < this->$name$_size(); i++) {\n"
|
||||
" data_size += ::google::protobuf::internal::WireFormatLite::EnumSize(\n"
|
||||
" this->$name$(i));\n"
|
||||
"}\n");
|
||||
|
||||
if (descriptor_->options().packed()) {
|
||||
printer->Print(variables_,
|
||||
"if (data_size > 0) {\n"
|
||||
" total_size += $tag_size$ +\n"
|
||||
" ::google::protobuf::internal::WireFormatLite::Int32Size(data_size);\n"
|
||||
"}\n"
|
||||
"_$name$_cached_byte_size_ = data_size;\n"
|
||||
"total_size += data_size;\n");
|
||||
} else {
|
||||
printer->Print(variables_,
|
||||
"total_size += $tag_size$ * this->$name$_size() + data_size;\n");
|
||||
}
|
||||
printer->Outdent();
|
||||
printer->Print("}\n");
|
||||
}
|
||||
|
||||
} // namespace cpp
|
||||
} // namespace compiler
|
||||
} // namespace protobuf
|
||||
} // namespace google
|
||||
@ -1,103 +0,0 @@
|
||||
// Protocol Buffers - Google's data interchange format
|
||||
// Copyright 2008 Google Inc. All rights reserved.
|
||||
// http://code.google.com/p/protobuf/
|
||||
//
|
||||
// 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.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// 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.
|
||||
|
||||
// Author: kenton@google.com (Kenton Varda)
|
||||
// Based on original Protocol Buffers design by
|
||||
// Sanjay Ghemawat, Jeff Dean, and others.
|
||||
|
||||
#ifndef GOOGLE_PROTOBUF_COMPILER_CPP_ENUM_FIELD_H__
|
||||
#define GOOGLE_PROTOBUF_COMPILER_CPP_ENUM_FIELD_H__
|
||||
|
||||
#include <map>
|
||||
#include <string>
|
||||
#include <google/protobuf/compiler/cpp/cpp_field.h>
|
||||
|
||||
namespace google {
|
||||
namespace protobuf {
|
||||
namespace compiler {
|
||||
namespace cpp {
|
||||
|
||||
class EnumFieldGenerator : public FieldGenerator {
|
||||
public:
|
||||
explicit EnumFieldGenerator(const FieldDescriptor* descriptor);
|
||||
~EnumFieldGenerator();
|
||||
|
||||
// implements FieldGenerator ---------------------------------------
|
||||
void GeneratePrivateMembers(io::Printer* printer) const;
|
||||
void GenerateAccessorDeclarations(io::Printer* printer) const;
|
||||
void GenerateInlineAccessorDefinitions(io::Printer* printer) const;
|
||||
void GenerateClearingCode(io::Printer* printer) const;
|
||||
void GenerateMergingCode(io::Printer* printer) const;
|
||||
void GenerateSwappingCode(io::Printer* printer) const;
|
||||
void GenerateConstructorCode(io::Printer* printer) const;
|
||||
void GenerateMergeFromCodedStream(io::Printer* printer) const;
|
||||
void GenerateSerializeWithCachedSizes(io::Printer* printer) const;
|
||||
void GenerateSerializeWithCachedSizesToArray(io::Printer* printer) const;
|
||||
void GenerateByteSize(io::Printer* printer) const;
|
||||
|
||||
private:
|
||||
const FieldDescriptor* descriptor_;
|
||||
map<string, string> variables_;
|
||||
|
||||
GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(EnumFieldGenerator);
|
||||
};
|
||||
|
||||
class RepeatedEnumFieldGenerator : public FieldGenerator {
|
||||
public:
|
||||
explicit RepeatedEnumFieldGenerator(const FieldDescriptor* descriptor);
|
||||
~RepeatedEnumFieldGenerator();
|
||||
|
||||
// implements FieldGenerator ---------------------------------------
|
||||
void GeneratePrivateMembers(io::Printer* printer) const;
|
||||
void GenerateAccessorDeclarations(io::Printer* printer) const;
|
||||
void GenerateInlineAccessorDefinitions(io::Printer* printer) const;
|
||||
void GenerateClearingCode(io::Printer* printer) const;
|
||||
void GenerateMergingCode(io::Printer* printer) const;
|
||||
void GenerateSwappingCode(io::Printer* printer) const;
|
||||
void GenerateConstructorCode(io::Printer* printer) const;
|
||||
void GenerateMergeFromCodedStream(io::Printer* printer) const;
|
||||
void GenerateMergeFromCodedStreamWithPacking(io::Printer* printer) const;
|
||||
void GenerateSerializeWithCachedSizes(io::Printer* printer) const;
|
||||
void GenerateSerializeWithCachedSizesToArray(io::Printer* printer) const;
|
||||
void GenerateByteSize(io::Printer* printer) const;
|
||||
|
||||
private:
|
||||
const FieldDescriptor* descriptor_;
|
||||
map<string, string> variables_;
|
||||
|
||||
GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(RepeatedEnumFieldGenerator);
|
||||
};
|
||||
|
||||
} // namespace cpp
|
||||
} // namespace compiler
|
||||
} // namespace protobuf
|
||||
|
||||
} // namespace google
|
||||
#endif // GOOGLE_PROTOBUF_COMPILER_CPP_ENUM_FIELD_H__
|
||||
@ -1,210 +0,0 @@
|
||||
// Protocol Buffers - Google's data interchange format
|
||||
// Copyright 2008 Google Inc. All rights reserved.
|
||||
// http://code.google.com/p/protobuf/
|
||||
//
|
||||
// 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.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// 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.
|
||||
|
||||
// Author: kenton@google.com (Kenton Varda)
|
||||
// Based on original Protocol Buffers design by
|
||||
// Sanjay Ghemawat, Jeff Dean, and others.
|
||||
|
||||
#include <google/protobuf/compiler/cpp/cpp_extension.h>
|
||||
#include <map>
|
||||
#include <google/protobuf/compiler/cpp/cpp_helpers.h>
|
||||
#include <google/protobuf/stubs/strutil.h>
|
||||
#include <google/protobuf/io/printer.h>
|
||||
#include <google/protobuf/descriptor.pb.h>
|
||||
|
||||
namespace google {
|
||||
namespace protobuf {
|
||||
namespace compiler {
|
||||
namespace cpp {
|
||||
|
||||
namespace {
|
||||
|
||||
// Returns the fully-qualified class name of the message that this field
|
||||
// extends. This function is used in the Google-internal code to handle some
|
||||
// legacy cases.
|
||||
string ExtendeeClassName(const FieldDescriptor* descriptor) {
|
||||
const Descriptor* extendee = descriptor->containing_type();
|
||||
return ClassName(extendee, true);
|
||||
}
|
||||
|
||||
} // anonymous namespace
|
||||
|
||||
ExtensionGenerator::ExtensionGenerator(const FieldDescriptor* descriptor,
|
||||
const string& dllexport_decl)
|
||||
: descriptor_(descriptor),
|
||||
dllexport_decl_(dllexport_decl) {
|
||||
// Construct type_traits_.
|
||||
if (descriptor_->is_repeated()) {
|
||||
type_traits_ = "Repeated";
|
||||
}
|
||||
|
||||
switch (descriptor_->cpp_type()) {
|
||||
case FieldDescriptor::CPPTYPE_ENUM:
|
||||
type_traits_.append("EnumTypeTraits< ");
|
||||
type_traits_.append(ClassName(descriptor_->enum_type(), true));
|
||||
type_traits_.append(", ");
|
||||
type_traits_.append(ClassName(descriptor_->enum_type(), true));
|
||||
type_traits_.append("_IsValid>");
|
||||
break;
|
||||
case FieldDescriptor::CPPTYPE_STRING:
|
||||
type_traits_.append("StringTypeTraits");
|
||||
break;
|
||||
case FieldDescriptor::CPPTYPE_MESSAGE:
|
||||
type_traits_.append("MessageTypeTraits< ");
|
||||
type_traits_.append(ClassName(descriptor_->message_type(), true));
|
||||
type_traits_.append(" >");
|
||||
break;
|
||||
default:
|
||||
type_traits_.append("PrimitiveTypeTraits< ");
|
||||
type_traits_.append(PrimitiveTypeName(descriptor_->cpp_type()));
|
||||
type_traits_.append(" >");
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
ExtensionGenerator::~ExtensionGenerator() {}
|
||||
|
||||
void ExtensionGenerator::GenerateDeclaration(io::Printer* printer) {
|
||||
map<string, string> vars;
|
||||
vars["extendee" ] = ExtendeeClassName(descriptor_);
|
||||
vars["number" ] = SimpleItoa(descriptor_->number());
|
||||
vars["type_traits" ] = type_traits_;
|
||||
vars["name" ] = descriptor_->name();
|
||||
vars["field_type" ] = SimpleItoa(static_cast<int>(descriptor_->type()));
|
||||
vars["packed" ] = descriptor_->options().packed() ? "true" : "false";
|
||||
vars["constant_name"] = FieldConstantName(descriptor_);
|
||||
|
||||
// If this is a class member, it needs to be declared "static". Otherwise,
|
||||
// it needs to be "extern". In the latter case, it also needs the DLL
|
||||
// export/import specifier.
|
||||
if (descriptor_->extension_scope() == NULL) {
|
||||
vars["qualifier"] = "extern";
|
||||
if (!dllexport_decl_.empty()) {
|
||||
vars["qualifier"] = dllexport_decl_ + " " + vars["qualifier"];
|
||||
}
|
||||
} else {
|
||||
vars["qualifier"] = "static";
|
||||
}
|
||||
|
||||
printer->Print(vars,
|
||||
"static const int $constant_name$ = $number$;\n"
|
||||
"$qualifier$ ::google::protobuf::internal::ExtensionIdentifier< $extendee$,\n"
|
||||
" ::google::protobuf::internal::$type_traits$, $field_type$, $packed$ >\n"
|
||||
" $name$;\n"
|
||||
);
|
||||
|
||||
}
|
||||
|
||||
void ExtensionGenerator::GenerateDefinition(io::Printer* printer) {
|
||||
// If this is a class member, it needs to be declared in its class scope.
|
||||
string scope = (descriptor_->extension_scope() == NULL) ? "" :
|
||||
ClassName(descriptor_->extension_scope(), false) + "::";
|
||||
string name = scope + descriptor_->name();
|
||||
|
||||
map<string, string> vars;
|
||||
vars["extendee" ] = ExtendeeClassName(descriptor_);
|
||||
vars["type_traits" ] = type_traits_;
|
||||
vars["name" ] = name;
|
||||
vars["constant_name"] = FieldConstantName(descriptor_);
|
||||
vars["default" ] = DefaultValue(descriptor_);
|
||||
vars["field_type" ] = SimpleItoa(static_cast<int>(descriptor_->type()));
|
||||
vars["packed" ] = descriptor_->options().packed() ? "true" : "false";
|
||||
vars["scope" ] = scope;
|
||||
|
||||
if (descriptor_->cpp_type() == FieldDescriptor::CPPTYPE_STRING) {
|
||||
// We need to declare a global string which will contain the default value.
|
||||
// We cannot declare it at class scope because that would require exposing
|
||||
// it in the header which would be annoying for other reasons. So we
|
||||
// replace :: with _ in the name and declare it as a global.
|
||||
string global_name = StringReplace(name, "::", "_", true);
|
||||
vars["global_name"] = global_name;
|
||||
printer->Print(vars,
|
||||
"const ::std::string $global_name$_default($default$);\n");
|
||||
|
||||
// Update the default to refer to the string global.
|
||||
vars["default"] = global_name + "_default";
|
||||
}
|
||||
|
||||
// Likewise, class members need to declare the field constant variable.
|
||||
if (descriptor_->extension_scope() != NULL) {
|
||||
printer->Print(vars,
|
||||
"#ifndef _MSC_VER\n"
|
||||
"const int $scope$$constant_name$;\n"
|
||||
"#endif\n");
|
||||
}
|
||||
|
||||
printer->Print(vars,
|
||||
"::google::protobuf::internal::ExtensionIdentifier< $extendee$,\n"
|
||||
" ::google::protobuf::internal::$type_traits$, $field_type$, $packed$ >\n"
|
||||
" $name$($constant_name$, $default$);\n");
|
||||
}
|
||||
|
||||
void ExtensionGenerator::GenerateRegistration(io::Printer* printer) {
|
||||
map<string, string> vars;
|
||||
vars["extendee" ] = ExtendeeClassName(descriptor_);
|
||||
vars["number" ] = SimpleItoa(descriptor_->number());
|
||||
vars["field_type" ] = SimpleItoa(static_cast<int>(descriptor_->type()));
|
||||
vars["is_repeated"] = descriptor_->is_repeated() ? "true" : "false";
|
||||
vars["is_packed" ] = (descriptor_->is_repeated() &&
|
||||
descriptor_->options().packed())
|
||||
? "true" : "false";
|
||||
|
||||
switch (descriptor_->cpp_type()) {
|
||||
case FieldDescriptor::CPPTYPE_ENUM:
|
||||
printer->Print(vars,
|
||||
"::google::protobuf::internal::ExtensionSet::RegisterEnumExtension(\n"
|
||||
" &$extendee$::default_instance(),\n"
|
||||
" $number$, $field_type$, $is_repeated$, $is_packed$,\n");
|
||||
printer->Print(
|
||||
" &$type$_IsValid);\n",
|
||||
"type", ClassName(descriptor_->enum_type(), true));
|
||||
break;
|
||||
case FieldDescriptor::CPPTYPE_MESSAGE:
|
||||
printer->Print(vars,
|
||||
"::google::protobuf::internal::ExtensionSet::RegisterMessageExtension(\n"
|
||||
" &$extendee$::default_instance(),\n"
|
||||
" $number$, $field_type$, $is_repeated$, $is_packed$,\n");
|
||||
printer->Print(
|
||||
" &$type$::default_instance());\n",
|
||||
"type", ClassName(descriptor_->message_type(), true));
|
||||
break;
|
||||
default:
|
||||
printer->Print(vars,
|
||||
"::google::protobuf::internal::ExtensionSet::RegisterExtension(\n"
|
||||
" &$extendee$::default_instance(),\n"
|
||||
" $number$, $field_type$, $is_repeated$, $is_packed$);\n");
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
} // namespace cpp
|
||||
} // namespace compiler
|
||||
} // namespace protobuf
|
||||
} // namespace google
|
||||
@ -1,139 +0,0 @@
|
||||
// Protocol Buffers - Google's data interchange format
|
||||
// Copyright 2008 Google Inc. All rights reserved.
|
||||
// http://code.google.com/p/protobuf/
|
||||
//
|
||||
// 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.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// 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.
|
||||
|
||||
// Author: kenton@google.com (Kenton Varda)
|
||||
// Based on original Protocol Buffers design by
|
||||
// Sanjay Ghemawat, Jeff Dean, and others.
|
||||
|
||||
#include <google/protobuf/compiler/cpp/cpp_field.h>
|
||||
#include <google/protobuf/compiler/cpp/cpp_helpers.h>
|
||||
#include <google/protobuf/compiler/cpp/cpp_primitive_field.h>
|
||||
#include <google/protobuf/compiler/cpp/cpp_string_field.h>
|
||||
#include <google/protobuf/compiler/cpp/cpp_enum_field.h>
|
||||
#include <google/protobuf/compiler/cpp/cpp_message_field.h>
|
||||
#include <google/protobuf/descriptor.pb.h>
|
||||
#include <google/protobuf/wire_format.h>
|
||||
#include <google/protobuf/io/printer.h>
|
||||
#include <google/protobuf/stubs/common.h>
|
||||
#include <google/protobuf/stubs/strutil.h>
|
||||
|
||||
namespace google {
|
||||
namespace protobuf {
|
||||
namespace compiler {
|
||||
namespace cpp {
|
||||
|
||||
using internal::WireFormat;
|
||||
|
||||
void SetCommonFieldVariables(const FieldDescriptor* descriptor,
|
||||
map<string, string>* variables) {
|
||||
(*variables)["name"] = FieldName(descriptor);
|
||||
(*variables)["index"] = SimpleItoa(descriptor->index());
|
||||
(*variables)["number"] = SimpleItoa(descriptor->number());
|
||||
(*variables)["classname"] = ClassName(FieldScope(descriptor), false);
|
||||
(*variables)["declared_type"] = DeclaredTypeMethodName(descriptor->type());
|
||||
|
||||
(*variables)["tag_size"] = SimpleItoa(
|
||||
WireFormat::TagSize(descriptor->number(), descriptor->type()));
|
||||
(*variables)["deprecation"] = descriptor->options().deprecated()
|
||||
? " PROTOBUF_DEPRECATED" : "";
|
||||
|
||||
}
|
||||
|
||||
FieldGenerator::~FieldGenerator() {}
|
||||
|
||||
void FieldGenerator::
|
||||
GenerateMergeFromCodedStreamWithPacking(io::Printer* printer) const {
|
||||
// Reaching here indicates a bug. Cases are:
|
||||
// - This FieldGenerator should support packing, but this method should be
|
||||
// overridden.
|
||||
// - This FieldGenerator doesn't support packing, and this method should
|
||||
// never have been called.
|
||||
GOOGLE_LOG(FATAL) << "GenerateMergeFromCodedStreamWithPacking() "
|
||||
<< "called on field generator that does not support packing.";
|
||||
|
||||
}
|
||||
|
||||
FieldGeneratorMap::FieldGeneratorMap(const Descriptor* descriptor)
|
||||
: descriptor_(descriptor),
|
||||
field_generators_(
|
||||
new scoped_ptr<FieldGenerator>[descriptor->field_count()]) {
|
||||
// Construct all the FieldGenerators.
|
||||
for (int i = 0; i < descriptor->field_count(); i++) {
|
||||
field_generators_[i].reset(MakeGenerator(descriptor->field(i)));
|
||||
}
|
||||
}
|
||||
|
||||
FieldGenerator* FieldGeneratorMap::MakeGenerator(const FieldDescriptor* field) {
|
||||
if (field->is_repeated()) {
|
||||
switch (field->cpp_type()) {
|
||||
case FieldDescriptor::CPPTYPE_MESSAGE:
|
||||
return new RepeatedMessageFieldGenerator(field);
|
||||
case FieldDescriptor::CPPTYPE_STRING:
|
||||
switch (field->options().ctype()) {
|
||||
default: // RepeatedStringFieldGenerator handles unknown ctypes.
|
||||
case FieldOptions::STRING:
|
||||
return new RepeatedStringFieldGenerator(field);
|
||||
}
|
||||
case FieldDescriptor::CPPTYPE_ENUM:
|
||||
return new RepeatedEnumFieldGenerator(field);
|
||||
default:
|
||||
return new RepeatedPrimitiveFieldGenerator(field);
|
||||
}
|
||||
} else {
|
||||
switch (field->cpp_type()) {
|
||||
case FieldDescriptor::CPPTYPE_MESSAGE:
|
||||
return new MessageFieldGenerator(field);
|
||||
case FieldDescriptor::CPPTYPE_STRING:
|
||||
switch (field->options().ctype()) {
|
||||
default: // StringFieldGenerator handles unknown ctypes.
|
||||
case FieldOptions::STRING:
|
||||
return new StringFieldGenerator(field);
|
||||
}
|
||||
case FieldDescriptor::CPPTYPE_ENUM:
|
||||
return new EnumFieldGenerator(field);
|
||||
default:
|
||||
return new PrimitiveFieldGenerator(field);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
FieldGeneratorMap::~FieldGeneratorMap() {}
|
||||
|
||||
const FieldGenerator& FieldGeneratorMap::get(
|
||||
const FieldDescriptor* field) const {
|
||||
GOOGLE_CHECK_EQ(field->containing_type(), descriptor_);
|
||||
return *field_generators_[field->index()];
|
||||
}
|
||||
|
||||
|
||||
} // namespace cpp
|
||||
} // namespace compiler
|
||||
} // namespace protobuf
|
||||
} // namespace google
|
||||
@ -1,167 +0,0 @@
|
||||
// Protocol Buffers - Google's data interchange format
|
||||
// Copyright 2008 Google Inc. All rights reserved.
|
||||
// http://code.google.com/p/protobuf/
|
||||
//
|
||||
// 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.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// 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.
|
||||
|
||||
// Author: kenton@google.com (Kenton Varda)
|
||||
// Based on original Protocol Buffers design by
|
||||
// Sanjay Ghemawat, Jeff Dean, and others.
|
||||
|
||||
#ifndef GOOGLE_PROTOBUF_COMPILER_CPP_FIELD_H__
|
||||
#define GOOGLE_PROTOBUF_COMPILER_CPP_FIELD_H__
|
||||
|
||||
#include <map>
|
||||
#include <string>
|
||||
|
||||
#include <google/protobuf/stubs/common.h>
|
||||
#include <google/protobuf/descriptor.h>
|
||||
|
||||
namespace google {
|
||||
namespace protobuf {
|
||||
namespace io {
|
||||
class Printer; // printer.h
|
||||
}
|
||||
}
|
||||
|
||||
namespace protobuf {
|
||||
namespace compiler {
|
||||
namespace cpp {
|
||||
|
||||
// Helper function: set variables in the map that are the same for all
|
||||
// field code generators.
|
||||
// ['name', 'index', 'number', 'classname', 'declared_type', 'tag_size',
|
||||
// 'deprecation'].
|
||||
void SetCommonFieldVariables(const FieldDescriptor* descriptor,
|
||||
map<string, string>* variables);
|
||||
|
||||
class FieldGenerator {
|
||||
public:
|
||||
FieldGenerator() {}
|
||||
virtual ~FieldGenerator();
|
||||
|
||||
// Generate lines of code declaring members fields of the message class
|
||||
// needed to represent this field. These are placed inside the message
|
||||
// class.
|
||||
virtual void GeneratePrivateMembers(io::Printer* printer) const = 0;
|
||||
|
||||
// Generate prototypes for all of the accessor functions related to this
|
||||
// field. These are placed inside the class definition.
|
||||
virtual void GenerateAccessorDeclarations(io::Printer* printer) const = 0;
|
||||
|
||||
// Generate inline definitions of accessor functions for this field.
|
||||
// These are placed inside the header after all class definitions.
|
||||
virtual void GenerateInlineAccessorDefinitions(
|
||||
io::Printer* printer) const = 0;
|
||||
|
||||
// Generate definitions of accessors that aren't inlined. These are
|
||||
// placed somewhere in the .cc file.
|
||||
// Most field types don't need this, so the default implementation is empty.
|
||||
virtual void GenerateNonInlineAccessorDefinitions(
|
||||
io::Printer* printer) const {}
|
||||
|
||||
// Generate lines of code (statements, not declarations) which clear the
|
||||
// field. This is used to define the clear_$name$() method as well as
|
||||
// the Clear() method for the whole message.
|
||||
virtual void GenerateClearingCode(io::Printer* printer) const = 0;
|
||||
|
||||
// Generate lines of code (statements, not declarations) which merges the
|
||||
// contents of the field from the current message to the target message,
|
||||
// which is stored in the generated code variable "from".
|
||||
// This is used to fill in the MergeFrom method for the whole message.
|
||||
// Details of this usage can be found in message.cc under the
|
||||
// GenerateMergeFrom method.
|
||||
virtual void GenerateMergingCode(io::Printer* printer) const = 0;
|
||||
|
||||
// Generate lines of code (statements, not declarations) which swaps
|
||||
// this field and the corresponding field of another message, which
|
||||
// is stored in the generated code variable "other". This is used to
|
||||
// define the Swap method. Details of usage can be found in
|
||||
// message.cc under the GenerateSwap method.
|
||||
virtual void GenerateSwappingCode(io::Printer* printer) const = 0;
|
||||
|
||||
// Generate initialization code for private members declared by
|
||||
// GeneratePrivateMembers(). These go into the message class's SharedCtor()
|
||||
// method, invoked by each of the generated constructors.
|
||||
virtual void GenerateConstructorCode(io::Printer* printer) const = 0;
|
||||
|
||||
// Generate any code that needs to go in the class's SharedDtor() method,
|
||||
// invoked by the destructor.
|
||||
// Most field types don't need this, so the default implementation is empty.
|
||||
virtual void GenerateDestructorCode(io::Printer* printer) const {}
|
||||
|
||||
// Generate lines to decode this field, which will be placed inside the
|
||||
// message's MergeFromCodedStream() method.
|
||||
virtual void GenerateMergeFromCodedStream(io::Printer* printer) const = 0;
|
||||
|
||||
// Generate lines to decode this field from a packed value, which will be
|
||||
// placed inside the message's MergeFromCodedStream() method.
|
||||
virtual void GenerateMergeFromCodedStreamWithPacking(io::Printer* printer)
|
||||
const;
|
||||
|
||||
// Generate lines to serialize this field, which are placed within the
|
||||
// message's SerializeWithCachedSizes() method.
|
||||
virtual void GenerateSerializeWithCachedSizes(io::Printer* printer) const = 0;
|
||||
|
||||
// Generate lines to serialize this field directly to the array "target",
|
||||
// which are placed within the message's SerializeWithCachedSizesToArray()
|
||||
// method. This must also advance "target" past the written bytes.
|
||||
virtual void GenerateSerializeWithCachedSizesToArray(
|
||||
io::Printer* printer) const = 0;
|
||||
|
||||
// Generate lines to compute the serialized size of this field, which
|
||||
// are placed in the message's ByteSize() method.
|
||||
virtual void GenerateByteSize(io::Printer* printer) const = 0;
|
||||
|
||||
private:
|
||||
GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(FieldGenerator);
|
||||
};
|
||||
|
||||
// Convenience class which constructs FieldGenerators for a Descriptor.
|
||||
class FieldGeneratorMap {
|
||||
public:
|
||||
explicit FieldGeneratorMap(const Descriptor* descriptor);
|
||||
~FieldGeneratorMap();
|
||||
|
||||
const FieldGenerator& get(const FieldDescriptor* field) const;
|
||||
|
||||
private:
|
||||
const Descriptor* descriptor_;
|
||||
scoped_array<scoped_ptr<FieldGenerator> > field_generators_;
|
||||
|
||||
static FieldGenerator* MakeGenerator(const FieldDescriptor* field);
|
||||
|
||||
GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(FieldGeneratorMap);
|
||||
};
|
||||
|
||||
|
||||
} // namespace cpp
|
||||
} // namespace compiler
|
||||
} // namespace protobuf
|
||||
|
||||
} // namespace google
|
||||
#endif // GOOGLE_PROTOBUF_COMPILER_CPP_FIELD_H__
|
||||
@ -1,611 +0,0 @@
|
||||
// Protocol Buffers - Google's data interchange format
|
||||
// Copyright 2008 Google Inc. All rights reserved.
|
||||
// http://code.google.com/p/protobuf/
|
||||
//
|
||||
// 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.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// 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.
|
||||
|
||||
// Author: kenton@google.com (Kenton Varda)
|
||||
// Based on original Protocol Buffers design by
|
||||
// Sanjay Ghemawat, Jeff Dean, and others.
|
||||
|
||||
#include <google/protobuf/compiler/cpp/cpp_file.h>
|
||||
#include <google/protobuf/compiler/cpp/cpp_enum.h>
|
||||
#include <google/protobuf/compiler/cpp/cpp_service.h>
|
||||
#include <google/protobuf/compiler/cpp/cpp_extension.h>
|
||||
#include <google/protobuf/compiler/cpp/cpp_helpers.h>
|
||||
#include <google/protobuf/compiler/cpp/cpp_message.h>
|
||||
#include <google/protobuf/compiler/cpp/cpp_field.h>
|
||||
#include <google/protobuf/io/printer.h>
|
||||
#include <google/protobuf/descriptor.pb.h>
|
||||
#include <google/protobuf/stubs/strutil.h>
|
||||
|
||||
namespace google {
|
||||
namespace protobuf {
|
||||
namespace compiler {
|
||||
namespace cpp {
|
||||
|
||||
// ===================================================================
|
||||
|
||||
FileGenerator::FileGenerator(const FileDescriptor* file,
|
||||
const string& dllexport_decl)
|
||||
: file_(file),
|
||||
message_generators_(
|
||||
new scoped_ptr<MessageGenerator>[file->message_type_count()]),
|
||||
enum_generators_(
|
||||
new scoped_ptr<EnumGenerator>[file->enum_type_count()]),
|
||||
service_generators_(
|
||||
new scoped_ptr<ServiceGenerator>[file->service_count()]),
|
||||
extension_generators_(
|
||||
new scoped_ptr<ExtensionGenerator>[file->extension_count()]),
|
||||
dllexport_decl_(dllexport_decl) {
|
||||
|
||||
for (int i = 0; i < file->message_type_count(); i++) {
|
||||
message_generators_[i].reset(
|
||||
new MessageGenerator(file->message_type(i), dllexport_decl));
|
||||
}
|
||||
|
||||
for (int i = 0; i < file->enum_type_count(); i++) {
|
||||
enum_generators_[i].reset(
|
||||
new EnumGenerator(file->enum_type(i), dllexport_decl));
|
||||
}
|
||||
|
||||
for (int i = 0; i < file->service_count(); i++) {
|
||||
service_generators_[i].reset(
|
||||
new ServiceGenerator(file->service(i), dllexport_decl));
|
||||
}
|
||||
|
||||
for (int i = 0; i < file->extension_count(); i++) {
|
||||
extension_generators_[i].reset(
|
||||
new ExtensionGenerator(file->extension(i), dllexport_decl));
|
||||
}
|
||||
|
||||
SplitStringUsing(file_->package(), ".", &package_parts_);
|
||||
}
|
||||
|
||||
FileGenerator::~FileGenerator() {}
|
||||
|
||||
void FileGenerator::GenerateHeader(io::Printer* printer) {
|
||||
string filename_identifier = FilenameIdentifier(file_->name());
|
||||
|
||||
// Generate top of header.
|
||||
printer->Print(
|
||||
"// Generated by the protocol buffer compiler. DO NOT EDIT!\n"
|
||||
"// source: $filename$\n"
|
||||
"\n"
|
||||
"#ifndef PROTOBUF_$filename_identifier$__INCLUDED\n"
|
||||
"#define PROTOBUF_$filename_identifier$__INCLUDED\n"
|
||||
"\n"
|
||||
"#include <string>\n"
|
||||
"\n",
|
||||
"filename", file_->name(),
|
||||
"filename_identifier", filename_identifier);
|
||||
|
||||
printer->Print(
|
||||
"#include <google/protobuf/stubs/common.h>\n"
|
||||
"\n");
|
||||
|
||||
// Verify the protobuf library header version is compatible with the protoc
|
||||
// version before going any further.
|
||||
printer->Print(
|
||||
"#if GOOGLE_PROTOBUF_VERSION < $min_header_version$\n"
|
||||
"#error This file was generated by a newer version of protoc which is\n"
|
||||
"#error incompatible with your Protocol Buffer headers. Please update\n"
|
||||
"#error your headers.\n"
|
||||
"#endif\n"
|
||||
"#if $protoc_version$ < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION\n"
|
||||
"#error This file was generated by an older version of protoc which is\n"
|
||||
"#error incompatible with your Protocol Buffer headers. Please\n"
|
||||
"#error regenerate this file with a newer version of protoc.\n"
|
||||
"#endif\n"
|
||||
"\n",
|
||||
"min_header_version",
|
||||
SimpleItoa(protobuf::internal::kMinHeaderVersionForProtoc),
|
||||
"protoc_version", SimpleItoa(GOOGLE_PROTOBUF_VERSION));
|
||||
|
||||
// OK, it's now safe to #include other files.
|
||||
printer->Print(
|
||||
"#include <google/protobuf/generated_message_util.h>\n"
|
||||
"#include <google/protobuf/repeated_field.h>\n"
|
||||
"#include <google/protobuf/extension_set.h>\n");
|
||||
|
||||
if (HasDescriptorMethods(file_)) {
|
||||
printer->Print(
|
||||
"#include <google/protobuf/generated_message_reflection.h>\n");
|
||||
}
|
||||
|
||||
if (HasGenericServices(file_)) {
|
||||
printer->Print(
|
||||
"#include <google/protobuf/service.h>\n");
|
||||
}
|
||||
|
||||
|
||||
for (int i = 0; i < file_->dependency_count(); i++) {
|
||||
printer->Print(
|
||||
"#include \"$dependency$.pb.h\"\n",
|
||||
"dependency", StripProto(file_->dependency(i)->name()));
|
||||
}
|
||||
|
||||
printer->Print(
|
||||
"// @@protoc_insertion_point(includes)\n");
|
||||
|
||||
// Open namespace.
|
||||
GenerateNamespaceOpeners(printer);
|
||||
|
||||
// Forward-declare the AddDescriptors, AssignDescriptors, and ShutdownFile
|
||||
// functions, so that we can declare them to be friends of each class.
|
||||
printer->Print(
|
||||
"\n"
|
||||
"// Internal implementation detail -- do not call these.\n"
|
||||
"void $dllexport_decl$ $adddescriptorsname$();\n",
|
||||
"adddescriptorsname", GlobalAddDescriptorsName(file_->name()),
|
||||
"dllexport_decl", dllexport_decl_);
|
||||
|
||||
printer->Print(
|
||||
// Note that we don't put dllexport_decl on these because they are only
|
||||
// called by the .pb.cc file in which they are defined.
|
||||
"void $assigndescriptorsname$();\n"
|
||||
"void $shutdownfilename$();\n"
|
||||
"\n",
|
||||
"assigndescriptorsname", GlobalAssignDescriptorsName(file_->name()),
|
||||
"shutdownfilename", GlobalShutdownFileName(file_->name()));
|
||||
|
||||
// Generate forward declarations of classes.
|
||||
for (int i = 0; i < file_->message_type_count(); i++) {
|
||||
message_generators_[i]->GenerateForwardDeclaration(printer);
|
||||
}
|
||||
|
||||
printer->Print("\n");
|
||||
|
||||
// Generate enum definitions.
|
||||
for (int i = 0; i < file_->message_type_count(); i++) {
|
||||
message_generators_[i]->GenerateEnumDefinitions(printer);
|
||||
}
|
||||
for (int i = 0; i < file_->enum_type_count(); i++) {
|
||||
enum_generators_[i]->GenerateDefinition(printer);
|
||||
}
|
||||
|
||||
printer->Print(kThickSeparator);
|
||||
printer->Print("\n");
|
||||
|
||||
// Generate class definitions.
|
||||
for (int i = 0; i < file_->message_type_count(); i++) {
|
||||
if (i > 0) {
|
||||
printer->Print("\n");
|
||||
printer->Print(kThinSeparator);
|
||||
printer->Print("\n");
|
||||
}
|
||||
message_generators_[i]->GenerateClassDefinition(printer);
|
||||
}
|
||||
|
||||
printer->Print("\n");
|
||||
printer->Print(kThickSeparator);
|
||||
printer->Print("\n");
|
||||
|
||||
if (HasGenericServices(file_)) {
|
||||
// Generate service definitions.
|
||||
for (int i = 0; i < file_->service_count(); i++) {
|
||||
if (i > 0) {
|
||||
printer->Print("\n");
|
||||
printer->Print(kThinSeparator);
|
||||
printer->Print("\n");
|
||||
}
|
||||
service_generators_[i]->GenerateDeclarations(printer);
|
||||
}
|
||||
|
||||
printer->Print("\n");
|
||||
printer->Print(kThickSeparator);
|
||||
printer->Print("\n");
|
||||
}
|
||||
|
||||
// Declare extension identifiers.
|
||||
for (int i = 0; i < file_->extension_count(); i++) {
|
||||
extension_generators_[i]->GenerateDeclaration(printer);
|
||||
}
|
||||
|
||||
printer->Print("\n");
|
||||
printer->Print(kThickSeparator);
|
||||
printer->Print("\n");
|
||||
|
||||
// Generate class inline methods.
|
||||
for (int i = 0; i < file_->message_type_count(); i++) {
|
||||
if (i > 0) {
|
||||
printer->Print(kThinSeparator);
|
||||
printer->Print("\n");
|
||||
}
|
||||
message_generators_[i]->GenerateInlineMethods(printer);
|
||||
}
|
||||
|
||||
printer->Print(
|
||||
"\n"
|
||||
"// @@protoc_insertion_point(namespace_scope)\n");
|
||||
|
||||
// Close up namespace.
|
||||
GenerateNamespaceClosers(printer);
|
||||
|
||||
// Emit GetEnumDescriptor specializations into google::protobuf namespace:
|
||||
if (HasDescriptorMethods(file_)) {
|
||||
// The SWIG conditional is to avoid a null-pointer dereference
|
||||
// (bug 1984964) in swig-1.3.21 resulting from the following syntax:
|
||||
// namespace X { void Y<Z::W>(); }
|
||||
// which appears in GetEnumDescriptor() specializations.
|
||||
printer->Print(
|
||||
"\n"
|
||||
"#ifndef SWIG\n"
|
||||
"namespace google {\nnamespace protobuf {\n"
|
||||
"\n");
|
||||
for (int i = 0; i < file_->message_type_count(); i++) {
|
||||
message_generators_[i]->GenerateGetEnumDescriptorSpecializations(printer);
|
||||
}
|
||||
for (int i = 0; i < file_->enum_type_count(); i++) {
|
||||
enum_generators_[i]->GenerateGetEnumDescriptorSpecializations(printer);
|
||||
}
|
||||
printer->Print(
|
||||
"\n"
|
||||
"} // namespace google\n} // namespace protobuf\n"
|
||||
"#endif // SWIG\n");
|
||||
}
|
||||
|
||||
printer->Print(
|
||||
"\n"
|
||||
"// @@protoc_insertion_point(global_scope)\n"
|
||||
"\n");
|
||||
|
||||
printer->Print(
|
||||
"#endif // PROTOBUF_$filename_identifier$__INCLUDED\n",
|
||||
"filename_identifier", filename_identifier);
|
||||
}
|
||||
|
||||
void FileGenerator::GenerateSource(io::Printer* printer) {
|
||||
printer->Print(
|
||||
"// Generated by the protocol buffer compiler. DO NOT EDIT!\n"
|
||||
"\n"
|
||||
|
||||
// The generated code calls accessors that might be deprecated. We don't
|
||||
// want the compiler to warn in generated code.
|
||||
"#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION\n"
|
||||
"#include \"$basename$.pb.h\"\n"
|
||||
"\n"
|
||||
"#include <algorithm>\n" // for swap()
|
||||
"\n"
|
||||
"#include <google/protobuf/stubs/once.h>\n"
|
||||
"#include <google/protobuf/io/coded_stream.h>\n"
|
||||
"#include <google/protobuf/wire_format_lite_inl.h>\n",
|
||||
"basename", StripProto(file_->name()));
|
||||
|
||||
if (HasDescriptorMethods(file_)) {
|
||||
printer->Print(
|
||||
"#include <google/protobuf/descriptor.h>\n"
|
||||
"#include <google/protobuf/reflection_ops.h>\n"
|
||||
"#include <google/protobuf/wire_format.h>\n");
|
||||
}
|
||||
|
||||
printer->Print(
|
||||
"// @@protoc_insertion_point(includes)\n");
|
||||
|
||||
GenerateNamespaceOpeners(printer);
|
||||
|
||||
if (HasDescriptorMethods(file_)) {
|
||||
printer->Print(
|
||||
"\n"
|
||||
"namespace {\n"
|
||||
"\n");
|
||||
for (int i = 0; i < file_->message_type_count(); i++) {
|
||||
message_generators_[i]->GenerateDescriptorDeclarations(printer);
|
||||
}
|
||||
for (int i = 0; i < file_->enum_type_count(); i++) {
|
||||
printer->Print(
|
||||
"const ::google::protobuf::EnumDescriptor* $name$_descriptor_ = NULL;\n",
|
||||
"name", ClassName(file_->enum_type(i), false));
|
||||
}
|
||||
|
||||
if (HasGenericServices(file_)) {
|
||||
for (int i = 0; i < file_->service_count(); i++) {
|
||||
printer->Print(
|
||||
"const ::google::protobuf::ServiceDescriptor* $name$_descriptor_ = NULL;\n",
|
||||
"name", file_->service(i)->name());
|
||||
}
|
||||
}
|
||||
|
||||
printer->Print(
|
||||
"\n"
|
||||
"} // namespace\n"
|
||||
"\n");
|
||||
}
|
||||
|
||||
// Define our externally-visible BuildDescriptors() function. (For the lite
|
||||
// library, all this does is initialize default instances.)
|
||||
GenerateBuildDescriptors(printer);
|
||||
|
||||
// Generate enums.
|
||||
for (int i = 0; i < file_->enum_type_count(); i++) {
|
||||
enum_generators_[i]->GenerateMethods(printer);
|
||||
}
|
||||
|
||||
// Generate classes.
|
||||
for (int i = 0; i < file_->message_type_count(); i++) {
|
||||
printer->Print("\n");
|
||||
printer->Print(kThickSeparator);
|
||||
printer->Print("\n");
|
||||
message_generators_[i]->GenerateClassMethods(printer);
|
||||
}
|
||||
|
||||
if (HasGenericServices(file_)) {
|
||||
// Generate services.
|
||||
for (int i = 0; i < file_->service_count(); i++) {
|
||||
if (i == 0) printer->Print("\n");
|
||||
printer->Print(kThickSeparator);
|
||||
printer->Print("\n");
|
||||
service_generators_[i]->GenerateImplementation(printer);
|
||||
}
|
||||
}
|
||||
|
||||
// Define extensions.
|
||||
for (int i = 0; i < file_->extension_count(); i++) {
|
||||
extension_generators_[i]->GenerateDefinition(printer);
|
||||
}
|
||||
|
||||
printer->Print(
|
||||
"\n"
|
||||
"// @@protoc_insertion_point(namespace_scope)\n");
|
||||
|
||||
GenerateNamespaceClosers(printer);
|
||||
|
||||
printer->Print(
|
||||
"\n"
|
||||
"// @@protoc_insertion_point(global_scope)\n");
|
||||
}
|
||||
|
||||
void FileGenerator::GenerateBuildDescriptors(io::Printer* printer) {
|
||||
// AddDescriptors() is a file-level procedure which adds the encoded
|
||||
// FileDescriptorProto for this .proto file to the global DescriptorPool
|
||||
// for generated files (DescriptorPool::generated_pool()). It always runs
|
||||
// at static initialization time, so all files will be registered before
|
||||
// main() starts. This procedure also constructs default instances and
|
||||
// registers extensions.
|
||||
//
|
||||
// Its sibling, AssignDescriptors(), actually pulls the compiled
|
||||
// FileDescriptor from the DescriptorPool and uses it to populate all of
|
||||
// the global variables which store pointers to the descriptor objects.
|
||||
// It also constructs the reflection objects. It is called the first time
|
||||
// anyone calls descriptor() or GetReflection() on one of the types defined
|
||||
// in the file.
|
||||
|
||||
// In optimize_for = LITE_RUNTIME mode, we don't generate AssignDescriptors()
|
||||
// and we only use AddDescriptors() to allocate default instances.
|
||||
if (HasDescriptorMethods(file_)) {
|
||||
printer->Print(
|
||||
"\n"
|
||||
"void $assigndescriptorsname$() {\n",
|
||||
"assigndescriptorsname", GlobalAssignDescriptorsName(file_->name()));
|
||||
printer->Indent();
|
||||
|
||||
// Make sure the file has found its way into the pool. If a descriptor
|
||||
// is requested *during* static init then AddDescriptors() may not have
|
||||
// been called yet, so we call it manually. Note that it's fine if
|
||||
// AddDescriptors() is called multiple times.
|
||||
printer->Print(
|
||||
"$adddescriptorsname$();\n",
|
||||
"adddescriptorsname", GlobalAddDescriptorsName(file_->name()));
|
||||
|
||||
// Get the file's descriptor from the pool.
|
||||
printer->Print(
|
||||
"const ::google::protobuf::FileDescriptor* file =\n"
|
||||
" ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName(\n"
|
||||
" \"$filename$\");\n"
|
||||
// Note that this GOOGLE_CHECK is necessary to prevent a warning about "file"
|
||||
// being unused when compiling an empty .proto file.
|
||||
"GOOGLE_CHECK(file != NULL);\n",
|
||||
"filename", file_->name());
|
||||
|
||||
// Go through all the stuff defined in this file and generated code to
|
||||
// assign the global descriptor pointers based on the file descriptor.
|
||||
for (int i = 0; i < file_->message_type_count(); i++) {
|
||||
message_generators_[i]->GenerateDescriptorInitializer(printer, i);
|
||||
}
|
||||
for (int i = 0; i < file_->enum_type_count(); i++) {
|
||||
enum_generators_[i]->GenerateDescriptorInitializer(printer, i);
|
||||
}
|
||||
if (HasGenericServices(file_)) {
|
||||
for (int i = 0; i < file_->service_count(); i++) {
|
||||
service_generators_[i]->GenerateDescriptorInitializer(printer, i);
|
||||
}
|
||||
}
|
||||
|
||||
printer->Outdent();
|
||||
printer->Print(
|
||||
"}\n"
|
||||
"\n");
|
||||
|
||||
// ---------------------------------------------------------------
|
||||
|
||||
// protobuf_AssignDescriptorsOnce(): The first time it is called, calls
|
||||
// AssignDescriptors(). All later times, waits for the first call to
|
||||
// complete and then returns.
|
||||
printer->Print(
|
||||
"namespace {\n"
|
||||
"\n"
|
||||
"GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_);\n"
|
||||
"inline void protobuf_AssignDescriptorsOnce() {\n"
|
||||
" ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_,\n"
|
||||
" &$assigndescriptorsname$);\n"
|
||||
"}\n"
|
||||
"\n",
|
||||
"assigndescriptorsname", GlobalAssignDescriptorsName(file_->name()));
|
||||
|
||||
// protobuf_RegisterTypes(): Calls
|
||||
// MessageFactory::InternalRegisterGeneratedType() for each message type.
|
||||
printer->Print(
|
||||
"void protobuf_RegisterTypes(const ::std::string&) {\n"
|
||||
" protobuf_AssignDescriptorsOnce();\n");
|
||||
printer->Indent();
|
||||
|
||||
for (int i = 0; i < file_->message_type_count(); i++) {
|
||||
message_generators_[i]->GenerateTypeRegistrations(printer);
|
||||
}
|
||||
|
||||
printer->Outdent();
|
||||
printer->Print(
|
||||
"}\n"
|
||||
"\n"
|
||||
"} // namespace\n");
|
||||
}
|
||||
|
||||
// -----------------------------------------------------------------
|
||||
|
||||
// ShutdownFile(): Deletes descriptors, default instances, etc. on shutdown.
|
||||
printer->Print(
|
||||
"\n"
|
||||
"void $shutdownfilename$() {\n",
|
||||
"shutdownfilename", GlobalShutdownFileName(file_->name()));
|
||||
printer->Indent();
|
||||
|
||||
for (int i = 0; i < file_->message_type_count(); i++) {
|
||||
message_generators_[i]->GenerateShutdownCode(printer);
|
||||
}
|
||||
|
||||
printer->Outdent();
|
||||
printer->Print(
|
||||
"}\n");
|
||||
|
||||
// -----------------------------------------------------------------
|
||||
|
||||
// Now generate the AddDescriptors() function.
|
||||
printer->Print(
|
||||
"\n"
|
||||
"void $adddescriptorsname$() {\n"
|
||||
// We don't need any special synchronization here because this code is
|
||||
// called at static init time before any threads exist.
|
||||
" static bool already_here = false;\n"
|
||||
" if (already_here) return;\n"
|
||||
" already_here = true;\n"
|
||||
" GOOGLE_PROTOBUF_VERIFY_VERSION;\n"
|
||||
"\n",
|
||||
"adddescriptorsname", GlobalAddDescriptorsName(file_->name()));
|
||||
printer->Indent();
|
||||
|
||||
// Call the AddDescriptors() methods for all of our dependencies, to make
|
||||
// sure they get added first.
|
||||
for (int i = 0; i < file_->dependency_count(); i++) {
|
||||
const FileDescriptor* dependency = file_->dependency(i);
|
||||
// Print the namespace prefix for the dependency.
|
||||
vector<string> dependency_package_parts;
|
||||
SplitStringUsing(dependency->package(), ".", &dependency_package_parts);
|
||||
printer->Print("::");
|
||||
for (int i = 0; i < dependency_package_parts.size(); i++) {
|
||||
printer->Print("$name$::",
|
||||
"name", dependency_package_parts[i]);
|
||||
}
|
||||
// Call its AddDescriptors function.
|
||||
printer->Print(
|
||||
"$name$();\n",
|
||||
"name", GlobalAddDescriptorsName(dependency->name()));
|
||||
}
|
||||
|
||||
if (HasDescriptorMethods(file_)) {
|
||||
// Embed the descriptor. We simply serialize the entire FileDescriptorProto
|
||||
// and embed it as a string literal, which is parsed and built into real
|
||||
// descriptors at initialization time.
|
||||
FileDescriptorProto file_proto;
|
||||
file_->CopyTo(&file_proto);
|
||||
string file_data;
|
||||
file_proto.SerializeToString(&file_data);
|
||||
|
||||
printer->Print(
|
||||
"::google::protobuf::DescriptorPool::InternalAddGeneratedFile(");
|
||||
|
||||
// Only write 40 bytes per line.
|
||||
static const int kBytesPerLine = 40;
|
||||
for (int i = 0; i < file_data.size(); i += kBytesPerLine) {
|
||||
printer->Print("\n \"$data$\"",
|
||||
"data", EscapeTrigraphs(CEscape(file_data.substr(i, kBytesPerLine))));
|
||||
}
|
||||
printer->Print(
|
||||
", $size$);\n",
|
||||
"size", SimpleItoa(file_data.size()));
|
||||
|
||||
// Call MessageFactory::InternalRegisterGeneratedFile().
|
||||
printer->Print(
|
||||
"::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(\n"
|
||||
" \"$filename$\", &protobuf_RegisterTypes);\n",
|
||||
"filename", file_->name());
|
||||
}
|
||||
|
||||
// Allocate and initialize default instances. This can't be done lazily
|
||||
// since default instances are returned by simple accessors and are used with
|
||||
// extensions. Speaking of which, we also register extensions at this time.
|
||||
for (int i = 0; i < file_->message_type_count(); i++) {
|
||||
message_generators_[i]->GenerateDefaultInstanceAllocator(printer);
|
||||
}
|
||||
for (int i = 0; i < file_->extension_count(); i++) {
|
||||
extension_generators_[i]->GenerateRegistration(printer);
|
||||
}
|
||||
for (int i = 0; i < file_->message_type_count(); i++) {
|
||||
message_generators_[i]->GenerateDefaultInstanceInitializer(printer);
|
||||
}
|
||||
|
||||
printer->Print(
|
||||
"::google::protobuf::internal::OnShutdown(&$shutdownfilename$);\n",
|
||||
"shutdownfilename", GlobalShutdownFileName(file_->name()));
|
||||
|
||||
printer->Outdent();
|
||||
|
||||
printer->Print(
|
||||
"}\n"
|
||||
"\n"
|
||||
"// Force AddDescriptors() to be called at static initialization time.\n"
|
||||
"struct StaticDescriptorInitializer_$filename$ {\n"
|
||||
" StaticDescriptorInitializer_$filename$() {\n"
|
||||
" $adddescriptorsname$();\n"
|
||||
" }\n"
|
||||
"} static_descriptor_initializer_$filename$_;\n"
|
||||
"\n",
|
||||
"adddescriptorsname", GlobalAddDescriptorsName(file_->name()),
|
||||
"filename", FilenameIdentifier(file_->name()));
|
||||
}
|
||||
|
||||
void FileGenerator::GenerateNamespaceOpeners(io::Printer* printer) {
|
||||
if (package_parts_.size() > 0) printer->Print("\n");
|
||||
|
||||
for (int i = 0; i < package_parts_.size(); i++) {
|
||||
printer->Print("namespace $part$ {\n",
|
||||
"part", package_parts_[i]);
|
||||
}
|
||||
}
|
||||
|
||||
void FileGenerator::GenerateNamespaceClosers(io::Printer* printer) {
|
||||
if (package_parts_.size() > 0) printer->Print("\n");
|
||||
|
||||
for (int i = package_parts_.size() - 1; i >= 0; i--) {
|
||||
printer->Print("} // namespace $part$\n",
|
||||
"part", package_parts_[i]);
|
||||
}
|
||||
}
|
||||
|
||||
} // namespace cpp
|
||||
} // namespace compiler
|
||||
} // namespace protobuf
|
||||
} // namespace google
|
||||
@ -1,122 +0,0 @@
|
||||
// Protocol Buffers - Google's data interchange format
|
||||
// Copyright 2008 Google Inc. All rights reserved.
|
||||
// http://code.google.com/p/protobuf/
|
||||
//
|
||||
// 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.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// 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.
|
||||
|
||||
// Author: kenton@google.com (Kenton Varda)
|
||||
// Based on original Protocol Buffers design by
|
||||
// Sanjay Ghemawat, Jeff Dean, and others.
|
||||
|
||||
#include <google/protobuf/compiler/cpp/cpp_generator.h>
|
||||
|
||||
#include <vector>
|
||||
#include <utility>
|
||||
|
||||
#include <google/protobuf/compiler/cpp/cpp_file.h>
|
||||
#include <google/protobuf/compiler/cpp/cpp_helpers.h>
|
||||
#include <google/protobuf/io/printer.h>
|
||||
#include <google/protobuf/io/zero_copy_stream.h>
|
||||
#include <google/protobuf/descriptor.pb.h>
|
||||
|
||||
namespace google {
|
||||
namespace protobuf {
|
||||
namespace compiler {
|
||||
namespace cpp {
|
||||
|
||||
CppGenerator::CppGenerator() {}
|
||||
CppGenerator::~CppGenerator() {}
|
||||
|
||||
bool CppGenerator::Generate(const FileDescriptor* file,
|
||||
const string& parameter,
|
||||
GeneratorContext* generator_context,
|
||||
string* error) const {
|
||||
vector<pair<string, string> > options;
|
||||
ParseGeneratorParameter(parameter, &options);
|
||||
|
||||
// -----------------------------------------------------------------
|
||||
// parse generator options
|
||||
|
||||
// TODO(kenton): If we ever have more options, we may want to create a
|
||||
// class that encapsulates them which we can pass down to all the
|
||||
// generator classes. Currently we pass dllexport_decl down to all of
|
||||
// them via the constructors, but we don't want to have to add another
|
||||
// constructor parameter for every option.
|
||||
|
||||
// If the dllexport_decl option is passed to the compiler, we need to write
|
||||
// it in front of every symbol that should be exported if this .proto is
|
||||
// compiled into a Windows DLL. E.g., if the user invokes the protocol
|
||||
// compiler as:
|
||||
// protoc --cpp_out=dllexport_decl=FOO_EXPORT:outdir foo.proto
|
||||
// then we'll define classes like this:
|
||||
// class FOO_EXPORT Foo {
|
||||
// ...
|
||||
// }
|
||||
// FOO_EXPORT is a macro which should expand to __declspec(dllexport) or
|
||||
// __declspec(dllimport) depending on what is being compiled.
|
||||
string dllexport_decl;
|
||||
|
||||
for (int i = 0; i < options.size(); i++) {
|
||||
if (options[i].first == "dllexport_decl") {
|
||||
dllexport_decl = options[i].second;
|
||||
} else {
|
||||
*error = "Unknown generator option: " + options[i].first;
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
// -----------------------------------------------------------------
|
||||
|
||||
|
||||
string basename = StripProto(file->name());
|
||||
basename.append(".pb");
|
||||
|
||||
FileGenerator file_generator(file, dllexport_decl);
|
||||
|
||||
// Generate header.
|
||||
{
|
||||
scoped_ptr<io::ZeroCopyOutputStream> output(
|
||||
generator_context->Open(basename + ".h"));
|
||||
io::Printer printer(output.get(), '$');
|
||||
file_generator.GenerateHeader(&printer);
|
||||
}
|
||||
|
||||
// Generate cc file.
|
||||
{
|
||||
scoped_ptr<io::ZeroCopyOutputStream> output(
|
||||
generator_context->Open(basename + ".cc"));
|
||||
io::Printer printer(output.get(), '$');
|
||||
file_generator.GenerateSource(&printer);
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
} // namespace cpp
|
||||
} // namespace compiler
|
||||
} // namespace protobuf
|
||||
} // namespace google
|
||||
@ -1,347 +0,0 @@
|
||||
// Protocol Buffers - Google's data interchange format
|
||||
// Copyright 2008 Google Inc. All rights reserved.
|
||||
// http://code.google.com/p/protobuf/
|
||||
//
|
||||
// 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.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// 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.
|
||||
|
||||
// Author: kenton@google.com (Kenton Varda)
|
||||
// Based on original Protocol Buffers design by
|
||||
// Sanjay Ghemawat, Jeff Dean, and others.
|
||||
|
||||
#include <limits>
|
||||
#include <vector>
|
||||
#include <google/protobuf/stubs/hash.h>
|
||||
|
||||
#include <google/protobuf/compiler/cpp/cpp_helpers.h>
|
||||
#include <google/protobuf/stubs/common.h>
|
||||
#include <google/protobuf/stubs/strutil.h>
|
||||
#include <google/protobuf/stubs/substitute.h>
|
||||
|
||||
|
||||
namespace google {
|
||||
namespace protobuf {
|
||||
namespace compiler {
|
||||
namespace cpp {
|
||||
|
||||
namespace {
|
||||
|
||||
string DotsToUnderscores(const string& name) {
|
||||
return StringReplace(name, ".", "_", true);
|
||||
}
|
||||
|
||||
string DotsToColons(const string& name) {
|
||||
return StringReplace(name, ".", "::", true);
|
||||
}
|
||||
|
||||
const char* const kKeywordList[] = {
|
||||
"and", "and_eq", "asm", "auto", "bitand", "bitor", "bool", "break", "case",
|
||||
"catch", "char", "class", "compl", "const", "const_cast", "continue",
|
||||
"default", "delete", "do", "double", "dynamic_cast", "else", "enum",
|
||||
"explicit", "extern", "false", "float", "for", "friend", "goto", "if",
|
||||
"inline", "int", "long", "mutable", "namespace", "new", "not", "not_eq",
|
||||
"operator", "or", "or_eq", "private", "protected", "public", "register",
|
||||
"reinterpret_cast", "return", "short", "signed", "sizeof", "static",
|
||||
"static_cast", "struct", "switch", "template", "this", "throw", "true", "try",
|
||||
"typedef", "typeid", "typename", "union", "unsigned", "using", "virtual",
|
||||
"void", "volatile", "wchar_t", "while", "xor", "xor_eq"
|
||||
};
|
||||
|
||||
hash_set<string> MakeKeywordsMap() {
|
||||
hash_set<string> result;
|
||||
for (int i = 0; i < GOOGLE_ARRAYSIZE(kKeywordList); i++) {
|
||||
result.insert(kKeywordList[i]);
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
hash_set<string> kKeywords = MakeKeywordsMap();
|
||||
|
||||
string UnderscoresToCamelCase(const string& input, bool cap_next_letter) {
|
||||
string result;
|
||||
// Note: I distrust ctype.h due to locales.
|
||||
for (int i = 0; i < input.size(); i++) {
|
||||
if ('a' <= input[i] && input[i] <= 'z') {
|
||||
if (cap_next_letter) {
|
||||
result += input[i] + ('A' - 'a');
|
||||
} else {
|
||||
result += input[i];
|
||||
}
|
||||
cap_next_letter = false;
|
||||
} else if ('A' <= input[i] && input[i] <= 'Z') {
|
||||
// Capital letters are left as-is.
|
||||
result += input[i];
|
||||
cap_next_letter = false;
|
||||
} else if ('0' <= input[i] && input[i] <= '9') {
|
||||
result += input[i];
|
||||
cap_next_letter = true;
|
||||
} else {
|
||||
cap_next_letter = true;
|
||||
}
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
} // namespace
|
||||
|
||||
const char kThickSeparator[] =
|
||||
"// ===================================================================\n";
|
||||
const char kThinSeparator[] =
|
||||
"// -------------------------------------------------------------------\n";
|
||||
|
||||
string ClassName(const Descriptor* descriptor, bool qualified) {
|
||||
|
||||
// Find "outer", the descriptor of the top-level message in which
|
||||
// "descriptor" is embedded.
|
||||
const Descriptor* outer = descriptor;
|
||||
while (outer->containing_type() != NULL) outer = outer->containing_type();
|
||||
|
||||
const string& outer_name = outer->full_name();
|
||||
string inner_name = descriptor->full_name().substr(outer_name.size());
|
||||
|
||||
if (qualified) {
|
||||
return "::" + DotsToColons(outer_name) + DotsToUnderscores(inner_name);
|
||||
} else {
|
||||
return outer->name() + DotsToUnderscores(inner_name);
|
||||
}
|
||||
}
|
||||
|
||||
string ClassName(const EnumDescriptor* enum_descriptor, bool qualified) {
|
||||
if (enum_descriptor->containing_type() == NULL) {
|
||||
if (qualified) {
|
||||
return DotsToColons(enum_descriptor->full_name());
|
||||
} else {
|
||||
return enum_descriptor->name();
|
||||
}
|
||||
} else {
|
||||
string result = ClassName(enum_descriptor->containing_type(), qualified);
|
||||
result += '_';
|
||||
result += enum_descriptor->name();
|
||||
return result;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
string SuperClassName(const Descriptor* descriptor) {
|
||||
return HasDescriptorMethods(descriptor->file()) ?
|
||||
"::google::protobuf::Message" : "::google::protobuf::MessageLite";
|
||||
}
|
||||
|
||||
string FieldName(const FieldDescriptor* field) {
|
||||
string result = field->name();
|
||||
LowerString(&result);
|
||||
if (kKeywords.count(result) > 0) {
|
||||
result.append("_");
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
string FieldConstantName(const FieldDescriptor *field) {
|
||||
string field_name = UnderscoresToCamelCase(field->name(), true);
|
||||
string result = "k" + field_name + "FieldNumber";
|
||||
|
||||
if (!field->is_extension() &&
|
||||
field->containing_type()->FindFieldByCamelcaseName(
|
||||
field->camelcase_name()) != field) {
|
||||
// This field's camelcase name is not unique. As a hack, add the field
|
||||
// number to the constant name. This makes the constant rather useless,
|
||||
// but what can we do?
|
||||
result += "_" + SimpleItoa(field->number());
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
string FieldMessageTypeName(const FieldDescriptor* field) {
|
||||
// Note: The Google-internal version of Protocol Buffers uses this function
|
||||
// as a hook point for hacks to support legacy code.
|
||||
return ClassName(field->message_type(), true);
|
||||
}
|
||||
|
||||
string StripProto(const string& filename) {
|
||||
if (HasSuffixString(filename, ".protodevel")) {
|
||||
return StripSuffixString(filename, ".protodevel");
|
||||
} else {
|
||||
return StripSuffixString(filename, ".proto");
|
||||
}
|
||||
}
|
||||
|
||||
const char* PrimitiveTypeName(FieldDescriptor::CppType type) {
|
||||
switch (type) {
|
||||
case FieldDescriptor::CPPTYPE_INT32 : return "::google::protobuf::int32";
|
||||
case FieldDescriptor::CPPTYPE_INT64 : return "::google::protobuf::int64";
|
||||
case FieldDescriptor::CPPTYPE_UINT32 : return "::google::protobuf::uint32";
|
||||
case FieldDescriptor::CPPTYPE_UINT64 : return "::google::protobuf::uint64";
|
||||
case FieldDescriptor::CPPTYPE_DOUBLE : return "double";
|
||||
case FieldDescriptor::CPPTYPE_FLOAT : return "float";
|
||||
case FieldDescriptor::CPPTYPE_BOOL : return "bool";
|
||||
case FieldDescriptor::CPPTYPE_ENUM : return "int";
|
||||
case FieldDescriptor::CPPTYPE_STRING : return "::std::string";
|
||||
case FieldDescriptor::CPPTYPE_MESSAGE: return NULL;
|
||||
|
||||
// No default because we want the compiler to complain if any new
|
||||
// CppTypes are added.
|
||||
}
|
||||
|
||||
GOOGLE_LOG(FATAL) << "Can't get here.";
|
||||
return NULL;
|
||||
}
|
||||
|
||||
const char* DeclaredTypeMethodName(FieldDescriptor::Type type) {
|
||||
switch (type) {
|
||||
case FieldDescriptor::TYPE_INT32 : return "Int32";
|
||||
case FieldDescriptor::TYPE_INT64 : return "Int64";
|
||||
case FieldDescriptor::TYPE_UINT32 : return "UInt32";
|
||||
case FieldDescriptor::TYPE_UINT64 : return "UInt64";
|
||||
case FieldDescriptor::TYPE_SINT32 : return "SInt32";
|
||||
case FieldDescriptor::TYPE_SINT64 : return "SInt64";
|
||||
case FieldDescriptor::TYPE_FIXED32 : return "Fixed32";
|
||||
case FieldDescriptor::TYPE_FIXED64 : return "Fixed64";
|
||||
case FieldDescriptor::TYPE_SFIXED32: return "SFixed32";
|
||||
case FieldDescriptor::TYPE_SFIXED64: return "SFixed64";
|
||||
case FieldDescriptor::TYPE_FLOAT : return "Float";
|
||||
case FieldDescriptor::TYPE_DOUBLE : return "Double";
|
||||
|
||||
case FieldDescriptor::TYPE_BOOL : return "Bool";
|
||||
case FieldDescriptor::TYPE_ENUM : return "Enum";
|
||||
|
||||
case FieldDescriptor::TYPE_STRING : return "String";
|
||||
case FieldDescriptor::TYPE_BYTES : return "Bytes";
|
||||
case FieldDescriptor::TYPE_GROUP : return "Group";
|
||||
case FieldDescriptor::TYPE_MESSAGE : return "Message";
|
||||
|
||||
// No default because we want the compiler to complain if any new
|
||||
// types are added.
|
||||
}
|
||||
GOOGLE_LOG(FATAL) << "Can't get here.";
|
||||
return "";
|
||||
}
|
||||
|
||||
string DefaultValue(const FieldDescriptor* field) {
|
||||
switch (field->cpp_type()) {
|
||||
case FieldDescriptor::CPPTYPE_INT32:
|
||||
return SimpleItoa(field->default_value_int32());
|
||||
case FieldDescriptor::CPPTYPE_UINT32:
|
||||
return SimpleItoa(field->default_value_uint32()) + "u";
|
||||
case FieldDescriptor::CPPTYPE_INT64:
|
||||
return "GOOGLE_LONGLONG(" + SimpleItoa(field->default_value_int64()) + ")";
|
||||
case FieldDescriptor::CPPTYPE_UINT64:
|
||||
return "GOOGLE_ULONGLONG(" + SimpleItoa(field->default_value_uint64())+ ")";
|
||||
case FieldDescriptor::CPPTYPE_DOUBLE: {
|
||||
double value = field->default_value_double();
|
||||
if (value == numeric_limits<double>::infinity()) {
|
||||
return "::google::protobuf::internal::Infinity()";
|
||||
} else if (value == -numeric_limits<double>::infinity()) {
|
||||
return "-::google::protobuf::internal::Infinity()";
|
||||
} else if (value != value) {
|
||||
return "::google::protobuf::internal::NaN()";
|
||||
} else {
|
||||
return SimpleDtoa(value);
|
||||
}
|
||||
}
|
||||
case FieldDescriptor::CPPTYPE_FLOAT:
|
||||
{
|
||||
float value = field->default_value_float();
|
||||
if (value == numeric_limits<float>::infinity()) {
|
||||
return "static_cast<float>(::google::protobuf::internal::Infinity())";
|
||||
} else if (value == -numeric_limits<float>::infinity()) {
|
||||
return "static_cast<float>(-::google::protobuf::internal::Infinity())";
|
||||
} else if (value != value) {
|
||||
return "static_cast<float>(::google::protobuf::internal::NaN())";
|
||||
} else {
|
||||
string float_value = SimpleFtoa(value);
|
||||
// If floating point value contains a period (.) or an exponent
|
||||
// (either E or e), then append suffix 'f' to make it a float
|
||||
// literal.
|
||||
if (float_value.find_first_of(".eE") != string::npos) {
|
||||
float_value.push_back('f');
|
||||
}
|
||||
return float_value;
|
||||
}
|
||||
}
|
||||
case FieldDescriptor::CPPTYPE_BOOL:
|
||||
return field->default_value_bool() ? "true" : "false";
|
||||
case FieldDescriptor::CPPTYPE_ENUM:
|
||||
// Lazy: Generate a static_cast because we don't have a helper function
|
||||
// that constructs the full name of an enum value.
|
||||
return strings::Substitute(
|
||||
"static_cast< $0 >($1)",
|
||||
ClassName(field->enum_type(), true),
|
||||
field->default_value_enum()->number());
|
||||
case FieldDescriptor::CPPTYPE_STRING:
|
||||
return "\"" + EscapeTrigraphs(CEscape(field->default_value_string())) +
|
||||
"\"";
|
||||
case FieldDescriptor::CPPTYPE_MESSAGE:
|
||||
return FieldMessageTypeName(field) + "::default_instance()";
|
||||
}
|
||||
// Can't actually get here; make compiler happy. (We could add a default
|
||||
// case above but then we wouldn't get the nice compiler warning when a
|
||||
// new type is added.)
|
||||
GOOGLE_LOG(FATAL) << "Can't get here.";
|
||||
return "";
|
||||
}
|
||||
|
||||
// Convert a file name into a valid identifier.
|
||||
string FilenameIdentifier(const string& filename) {
|
||||
string result;
|
||||
for (int i = 0; i < filename.size(); i++) {
|
||||
if (ascii_isalnum(filename[i])) {
|
||||
result.push_back(filename[i]);
|
||||
} else {
|
||||
// Not alphanumeric. To avoid any possibility of name conflicts we
|
||||
// use the hex code for the character.
|
||||
result.push_back('_');
|
||||
char buffer[kFastToBufferSize];
|
||||
result.append(FastHexToBuffer(static_cast<uint8>(filename[i]), buffer));
|
||||
}
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
// Return the name of the AddDescriptors() function for a given file.
|
||||
string GlobalAddDescriptorsName(const string& filename) {
|
||||
return "protobuf_AddDesc_" + FilenameIdentifier(filename);
|
||||
}
|
||||
|
||||
// Return the name of the AssignDescriptors() function for a given file.
|
||||
string GlobalAssignDescriptorsName(const string& filename) {
|
||||
return "protobuf_AssignDesc_" + FilenameIdentifier(filename);
|
||||
}
|
||||
|
||||
// Return the name of the ShutdownFile() function for a given file.
|
||||
string GlobalShutdownFileName(const string& filename) {
|
||||
return "protobuf_ShutdownFile_" + FilenameIdentifier(filename);
|
||||
}
|
||||
|
||||
// Escape C++ trigraphs by escaping question marks to \?
|
||||
string EscapeTrigraphs(const string& to_escape) {
|
||||
return StringReplace(to_escape, "?", "\\?", true);
|
||||
}
|
||||
|
||||
} // namespace cpp
|
||||
} // namespace compiler
|
||||
} // namespace protobuf
|
||||
} // namespace google
|
||||
@ -1,159 +0,0 @@
|
||||
// Protocol Buffers - Google's data interchange format
|
||||
// Copyright 2008 Google Inc. All rights reserved.
|
||||
// http://code.google.com/p/protobuf/
|
||||
//
|
||||
// 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.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// 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.
|
||||
|
||||
// Author: kenton@google.com (Kenton Varda)
|
||||
// Based on original Protocol Buffers design by
|
||||
// Sanjay Ghemawat, Jeff Dean, and others.
|
||||
|
||||
#ifndef GOOGLE_PROTOBUF_COMPILER_CPP_HELPERS_H__
|
||||
#define GOOGLE_PROTOBUF_COMPILER_CPP_HELPERS_H__
|
||||
|
||||
#include <string>
|
||||
#include <google/protobuf/descriptor.h>
|
||||
#include <google/protobuf/descriptor.pb.h>
|
||||
|
||||
namespace google {
|
||||
namespace protobuf {
|
||||
namespace compiler {
|
||||
namespace cpp {
|
||||
|
||||
// Commonly-used separator comments. Thick is a line of '=', thin is a line
|
||||
// of '-'.
|
||||
extern const char kThickSeparator[];
|
||||
extern const char kThinSeparator[];
|
||||
|
||||
// Returns the non-nested type name for the given type. If "qualified" is
|
||||
// true, prefix the type with the full namespace. For example, if you had:
|
||||
// package foo.bar;
|
||||
// message Baz { message Qux {} }
|
||||
// Then the qualified ClassName for Qux would be:
|
||||
// ::foo::bar::Baz_Qux
|
||||
// While the non-qualified version would be:
|
||||
// Baz_Qux
|
||||
string ClassName(const Descriptor* descriptor, bool qualified);
|
||||
string ClassName(const EnumDescriptor* enum_descriptor, bool qualified);
|
||||
|
||||
string SuperClassName(const Descriptor* descriptor);
|
||||
|
||||
// Get the (unqualified) name that should be used for this field in C++ code.
|
||||
// The name is coerced to lower-case to emulate proto1 behavior. People
|
||||
// should be using lowercase-with-underscores style for proto field names
|
||||
// anyway, so normally this just returns field->name().
|
||||
string FieldName(const FieldDescriptor* field);
|
||||
|
||||
// Get the unqualified name that should be used for a field's field
|
||||
// number constant.
|
||||
string FieldConstantName(const FieldDescriptor *field);
|
||||
|
||||
// Returns the scope where the field was defined (for extensions, this is
|
||||
// different from the message type to which the field applies).
|
||||
inline const Descriptor* FieldScope(const FieldDescriptor* field) {
|
||||
return field->is_extension() ?
|
||||
field->extension_scope() : field->containing_type();
|
||||
}
|
||||
|
||||
// Returns the fully-qualified type name field->message_type(). Usually this
|
||||
// is just ClassName(field->message_type(), true);
|
||||
string FieldMessageTypeName(const FieldDescriptor* field);
|
||||
|
||||
// Strips ".proto" or ".protodevel" from the end of a filename.
|
||||
string StripProto(const string& filename);
|
||||
|
||||
// Get the C++ type name for a primitive type (e.g. "double", "::google::protobuf::int32", etc.).
|
||||
// Note: non-built-in type names will be qualified, meaning they will start
|
||||
// with a ::. If you are using the type as a template parameter, you will
|
||||
// need to insure there is a space between the < and the ::, because the
|
||||
// ridiculous C++ standard defines "<:" to be a synonym for "[".
|
||||
const char* PrimitiveTypeName(FieldDescriptor::CppType type);
|
||||
|
||||
// Get the declared type name in CamelCase format, as is used e.g. for the
|
||||
// methods of WireFormat. For example, TYPE_INT32 becomes "Int32".
|
||||
const char* DeclaredTypeMethodName(FieldDescriptor::Type type);
|
||||
|
||||
// Get code that evaluates to the field's default value.
|
||||
string DefaultValue(const FieldDescriptor* field);
|
||||
|
||||
// Convert a file name into a valid identifier.
|
||||
string FilenameIdentifier(const string& filename);
|
||||
|
||||
// Return the name of the AddDescriptors() function for a given file.
|
||||
string GlobalAddDescriptorsName(const string& filename);
|
||||
|
||||
// Return the name of the AssignDescriptors() function for a given file.
|
||||
string GlobalAssignDescriptorsName(const string& filename);
|
||||
|
||||
// Return the name of the ShutdownFile() function for a given file.
|
||||
string GlobalShutdownFileName(const string& filename);
|
||||
|
||||
// Escape C++ trigraphs by escaping question marks to \?
|
||||
string EscapeTrigraphs(const string& to_escape);
|
||||
|
||||
// Do message classes in this file keep track of unknown fields?
|
||||
inline bool HasUnknownFields(const FileDescriptor *file) {
|
||||
return file->options().optimize_for() != FileOptions::LITE_RUNTIME;
|
||||
}
|
||||
|
||||
// Does this file have generated parsing, serialization, and other
|
||||
// standard methods for which reflection-based fallback implementations exist?
|
||||
inline bool HasGeneratedMethods(const FileDescriptor *file) {
|
||||
return file->options().optimize_for() != FileOptions::CODE_SIZE;
|
||||
}
|
||||
|
||||
// Do message classes in this file have descriptor and refelction methods?
|
||||
inline bool HasDescriptorMethods(const FileDescriptor *file) {
|
||||
return file->options().optimize_for() != FileOptions::LITE_RUNTIME;
|
||||
}
|
||||
|
||||
// Should we generate generic services for this file?
|
||||
inline bool HasGenericServices(const FileDescriptor *file) {
|
||||
return file->service_count() > 0 &&
|
||||
file->options().optimize_for() != FileOptions::LITE_RUNTIME &&
|
||||
file->options().cc_generic_services();
|
||||
}
|
||||
|
||||
// Should string fields in this file verify that their contents are UTF-8?
|
||||
inline bool HasUtf8Verification(const FileDescriptor* file) {
|
||||
return file->options().optimize_for() != FileOptions::LITE_RUNTIME;
|
||||
}
|
||||
|
||||
// Should we generate a separate, super-optimized code path for serializing to
|
||||
// flat arrays? We don't do this in Lite mode because we'd rather reduce code
|
||||
// size.
|
||||
inline bool HasFastArraySerialization(const FileDescriptor* file) {
|
||||
return file->options().optimize_for() == FileOptions::SPEED;
|
||||
}
|
||||
|
||||
|
||||
} // namespace cpp
|
||||
} // namespace compiler
|
||||
} // namespace protobuf
|
||||
|
||||
} // namespace google
|
||||
#endif // GOOGLE_PROTOBUF_COMPILER_CPP_HELPERS_H__
|
||||
File diff suppressed because it is too large
Load Diff
@ -1,170 +0,0 @@
|
||||
// Protocol Buffers - Google's data interchange format
|
||||
// Copyright 2008 Google Inc. All rights reserved.
|
||||
// http://code.google.com/p/protobuf/
|
||||
//
|
||||
// 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.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// 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.
|
||||
|
||||
// Author: kenton@google.com (Kenton Varda)
|
||||
// Based on original Protocol Buffers design by
|
||||
// Sanjay Ghemawat, Jeff Dean, and others.
|
||||
|
||||
#ifndef GOOGLE_PROTOBUF_COMPILER_CPP_MESSAGE_H__
|
||||
#define GOOGLE_PROTOBUF_COMPILER_CPP_MESSAGE_H__
|
||||
|
||||
#include <string>
|
||||
#include <google/protobuf/stubs/common.h>
|
||||
#include <google/protobuf/compiler/cpp/cpp_field.h>
|
||||
|
||||
namespace google {
|
||||
namespace protobuf {
|
||||
namespace io {
|
||||
class Printer; // printer.h
|
||||
}
|
||||
}
|
||||
|
||||
namespace protobuf {
|
||||
namespace compiler {
|
||||
namespace cpp {
|
||||
|
||||
class EnumGenerator; // enum.h
|
||||
class ExtensionGenerator; // extension.h
|
||||
|
||||
class MessageGenerator {
|
||||
public:
|
||||
// See generator.cc for the meaning of dllexport_decl.
|
||||
explicit MessageGenerator(const Descriptor* descriptor,
|
||||
const string& dllexport_decl);
|
||||
~MessageGenerator();
|
||||
|
||||
// Header stuff.
|
||||
|
||||
// Generate foward declarations for this class and all its nested types.
|
||||
void GenerateForwardDeclaration(io::Printer* printer);
|
||||
|
||||
// Generate definitions of all nested enums (must come before class
|
||||
// definitions because those classes use the enums definitions).
|
||||
void GenerateEnumDefinitions(io::Printer* printer);
|
||||
|
||||
// Generate specializations of GetEnumDescriptor<MyEnum>().
|
||||
// Precondition: in ::google::protobuf namespace.
|
||||
void GenerateGetEnumDescriptorSpecializations(io::Printer* printer);
|
||||
|
||||
// Generate definitions for this class and all its nested types.
|
||||
void GenerateClassDefinition(io::Printer* printer);
|
||||
|
||||
// Generate definitions of inline methods (placed at the end of the header
|
||||
// file).
|
||||
void GenerateInlineMethods(io::Printer* printer);
|
||||
|
||||
// Source file stuff.
|
||||
|
||||
// Generate code which declares all the global descriptor pointers which
|
||||
// will be initialized by the methods below.
|
||||
void GenerateDescriptorDeclarations(io::Printer* printer);
|
||||
|
||||
// Generate code that initializes the global variable storing the message's
|
||||
// descriptor.
|
||||
void GenerateDescriptorInitializer(io::Printer* printer, int index);
|
||||
|
||||
// Generate code that calls MessageFactory::InternalRegisterGeneratedMessage()
|
||||
// for all types.
|
||||
void GenerateTypeRegistrations(io::Printer* printer);
|
||||
|
||||
// Generates code that allocates the message's default instance.
|
||||
void GenerateDefaultInstanceAllocator(io::Printer* printer);
|
||||
|
||||
// Generates code that initializes the message's default instance. This
|
||||
// is separate from allocating because all default instances must be
|
||||
// allocated before any can be initialized.
|
||||
void GenerateDefaultInstanceInitializer(io::Printer* printer);
|
||||
|
||||
// Generates code that should be run when ShutdownProtobufLibrary() is called,
|
||||
// to delete all dynamically-allocated objects.
|
||||
void GenerateShutdownCode(io::Printer* printer);
|
||||
|
||||
// Generate all non-inline methods for this class.
|
||||
void GenerateClassMethods(io::Printer* printer);
|
||||
|
||||
private:
|
||||
// Generate declarations and definitions of accessors for fields.
|
||||
void GenerateFieldAccessorDeclarations(io::Printer* printer);
|
||||
void GenerateFieldAccessorDefinitions(io::Printer* printer);
|
||||
|
||||
// Generate the field offsets array.
|
||||
void GenerateOffsets(io::Printer* printer);
|
||||
|
||||
// Generate constructors and destructor.
|
||||
void GenerateStructors(io::Printer* printer);
|
||||
|
||||
// The compiler typically generates multiple copies of each constructor and
|
||||
// destructor: http://gcc.gnu.org/bugs.html#nonbugs_cxx
|
||||
// Placing common code in a separate method reduces the generated code size.
|
||||
//
|
||||
// Generate the shared constructor code.
|
||||
void GenerateSharedConstructorCode(io::Printer* printer);
|
||||
// Generate the shared destructor code.
|
||||
void GenerateSharedDestructorCode(io::Printer* printer);
|
||||
|
||||
// Generate standard Message methods.
|
||||
void GenerateClear(io::Printer* printer);
|
||||
void GenerateMergeFromCodedStream(io::Printer* printer);
|
||||
void GenerateSerializeWithCachedSizes(io::Printer* printer);
|
||||
void GenerateSerializeWithCachedSizesToArray(io::Printer* printer);
|
||||
void GenerateSerializeWithCachedSizesBody(io::Printer* printer,
|
||||
bool to_array);
|
||||
void GenerateByteSize(io::Printer* printer);
|
||||
void GenerateMergeFrom(io::Printer* printer);
|
||||
void GenerateCopyFrom(io::Printer* printer);
|
||||
void GenerateSwap(io::Printer* printer);
|
||||
void GenerateIsInitialized(io::Printer* printer);
|
||||
|
||||
// Helpers for GenerateSerializeWithCachedSizes().
|
||||
void GenerateSerializeOneField(io::Printer* printer,
|
||||
const FieldDescriptor* field,
|
||||
bool unbounded);
|
||||
void GenerateSerializeOneExtensionRange(
|
||||
io::Printer* printer, const Descriptor::ExtensionRange* range,
|
||||
bool unbounded);
|
||||
|
||||
|
||||
const Descriptor* descriptor_;
|
||||
string classname_;
|
||||
string dllexport_decl_;
|
||||
FieldGeneratorMap field_generators_;
|
||||
scoped_array<scoped_ptr<MessageGenerator> > nested_generators_;
|
||||
scoped_array<scoped_ptr<EnumGenerator> > enum_generators_;
|
||||
scoped_array<scoped_ptr<ExtensionGenerator> > extension_generators_;
|
||||
|
||||
GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(MessageGenerator);
|
||||
};
|
||||
|
||||
} // namespace cpp
|
||||
} // namespace compiler
|
||||
} // namespace protobuf
|
||||
|
||||
} // namespace google
|
||||
#endif // GOOGLE_PROTOBUF_COMPILER_CPP_MESSAGE_H__
|
||||
@ -1,277 +0,0 @@
|
||||
// Protocol Buffers - Google's data interchange format
|
||||
// Copyright 2008 Google Inc. All rights reserved.
|
||||
// http://code.google.com/p/protobuf/
|
||||
//
|
||||
// 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.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// 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.
|
||||
|
||||
// Author: kenton@google.com (Kenton Varda)
|
||||
// Based on original Protocol Buffers design by
|
||||
// Sanjay Ghemawat, Jeff Dean, and others.
|
||||
|
||||
#include <google/protobuf/compiler/cpp/cpp_message_field.h>
|
||||
#include <google/protobuf/compiler/cpp/cpp_helpers.h>
|
||||
#include <google/protobuf/io/printer.h>
|
||||
#include <google/protobuf/stubs/strutil.h>
|
||||
|
||||
namespace google {
|
||||
namespace protobuf {
|
||||
namespace compiler {
|
||||
namespace cpp {
|
||||
|
||||
namespace {
|
||||
|
||||
void SetMessageVariables(const FieldDescriptor* descriptor,
|
||||
map<string, string>* variables) {
|
||||
SetCommonFieldVariables(descriptor, variables);
|
||||
(*variables)["type"] = FieldMessageTypeName(descriptor);
|
||||
(*variables)["stream_writer"] = (*variables)["declared_type"] +
|
||||
(HasFastArraySerialization(descriptor->message_type()->file()) ?
|
||||
"MaybeToArray" :
|
||||
"");
|
||||
}
|
||||
|
||||
} // namespace
|
||||
|
||||
// ===================================================================
|
||||
|
||||
MessageFieldGenerator::
|
||||
MessageFieldGenerator(const FieldDescriptor* descriptor)
|
||||
: descriptor_(descriptor) {
|
||||
SetMessageVariables(descriptor, &variables_);
|
||||
}
|
||||
|
||||
MessageFieldGenerator::~MessageFieldGenerator() {}
|
||||
|
||||
void MessageFieldGenerator::
|
||||
GeneratePrivateMembers(io::Printer* printer) const {
|
||||
printer->Print(variables_, "$type$* $name$_;\n");
|
||||
}
|
||||
|
||||
void MessageFieldGenerator::
|
||||
GenerateAccessorDeclarations(io::Printer* printer) const {
|
||||
printer->Print(variables_,
|
||||
"inline const $type$& $name$() const$deprecation$;\n"
|
||||
"inline $type$* mutable_$name$()$deprecation$;\n"
|
||||
"inline $type$* release_$name$()$deprecation$;\n");
|
||||
}
|
||||
|
||||
void MessageFieldGenerator::
|
||||
GenerateInlineAccessorDefinitions(io::Printer* printer) const {
|
||||
printer->Print(variables_,
|
||||
"inline const $type$& $classname$::$name$() const {\n"
|
||||
" return $name$_ != NULL ? *$name$_ : *default_instance_->$name$_;\n"
|
||||
"}\n"
|
||||
"inline $type$* $classname$::mutable_$name$() {\n"
|
||||
" set_has_$name$();\n"
|
||||
" if ($name$_ == NULL) $name$_ = new $type$;\n"
|
||||
" return $name$_;\n"
|
||||
"}\n"
|
||||
"inline $type$* $classname$::release_$name$() {\n"
|
||||
" clear_has_$name$();\n"
|
||||
" $type$* temp = $name$_;\n"
|
||||
" $name$_ = NULL;\n"
|
||||
" return temp;\n"
|
||||
"}\n");
|
||||
}
|
||||
|
||||
void MessageFieldGenerator::
|
||||
GenerateClearingCode(io::Printer* printer) const {
|
||||
printer->Print(variables_,
|
||||
"if ($name$_ != NULL) $name$_->$type$::Clear();\n");
|
||||
}
|
||||
|
||||
void MessageFieldGenerator::
|
||||
GenerateMergingCode(io::Printer* printer) const {
|
||||
printer->Print(variables_,
|
||||
"mutable_$name$()->$type$::MergeFrom(from.$name$());\n");
|
||||
}
|
||||
|
||||
void MessageFieldGenerator::
|
||||
GenerateSwappingCode(io::Printer* printer) const {
|
||||
printer->Print(variables_, "std::swap($name$_, other->$name$_);\n");
|
||||
}
|
||||
|
||||
void MessageFieldGenerator::
|
||||
GenerateConstructorCode(io::Printer* printer) const {
|
||||
printer->Print(variables_, "$name$_ = NULL;\n");
|
||||
}
|
||||
|
||||
void MessageFieldGenerator::
|
||||
GenerateMergeFromCodedStream(io::Printer* printer) const {
|
||||
if (descriptor_->type() == FieldDescriptor::TYPE_MESSAGE) {
|
||||
printer->Print(variables_,
|
||||
"DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(\n"
|
||||
" input, mutable_$name$()));\n");
|
||||
} else {
|
||||
printer->Print(variables_,
|
||||
"DO_(::google::protobuf::internal::WireFormatLite::ReadGroupNoVirtual(\n"
|
||||
" $number$, input, mutable_$name$()));\n");
|
||||
}
|
||||
}
|
||||
|
||||
void MessageFieldGenerator::
|
||||
GenerateSerializeWithCachedSizes(io::Printer* printer) const {
|
||||
printer->Print(variables_,
|
||||
"::google::protobuf::internal::WireFormatLite::Write$stream_writer$(\n"
|
||||
" $number$, this->$name$(), output);\n");
|
||||
}
|
||||
|
||||
void MessageFieldGenerator::
|
||||
GenerateSerializeWithCachedSizesToArray(io::Printer* printer) const {
|
||||
printer->Print(variables_,
|
||||
"target = ::google::protobuf::internal::WireFormatLite::\n"
|
||||
" Write$declared_type$NoVirtualToArray(\n"
|
||||
" $number$, this->$name$(), target);\n");
|
||||
}
|
||||
|
||||
void MessageFieldGenerator::
|
||||
GenerateByteSize(io::Printer* printer) const {
|
||||
printer->Print(variables_,
|
||||
"total_size += $tag_size$ +\n"
|
||||
" ::google::protobuf::internal::WireFormatLite::$declared_type$SizeNoVirtual(\n"
|
||||
" this->$name$());\n");
|
||||
}
|
||||
|
||||
// ===================================================================
|
||||
|
||||
RepeatedMessageFieldGenerator::
|
||||
RepeatedMessageFieldGenerator(const FieldDescriptor* descriptor)
|
||||
: descriptor_(descriptor) {
|
||||
SetMessageVariables(descriptor, &variables_);
|
||||
}
|
||||
|
||||
RepeatedMessageFieldGenerator::~RepeatedMessageFieldGenerator() {}
|
||||
|
||||
void RepeatedMessageFieldGenerator::
|
||||
GeneratePrivateMembers(io::Printer* printer) const {
|
||||
printer->Print(variables_,
|
||||
"::google::protobuf::RepeatedPtrField< $type$ > $name$_;\n");
|
||||
}
|
||||
|
||||
void RepeatedMessageFieldGenerator::
|
||||
GenerateAccessorDeclarations(io::Printer* printer) const {
|
||||
printer->Print(variables_,
|
||||
"inline const $type$& $name$(int index) const$deprecation$;\n"
|
||||
"inline $type$* mutable_$name$(int index)$deprecation$;\n"
|
||||
"inline $type$* add_$name$()$deprecation$;\n");
|
||||
printer->Print(variables_,
|
||||
"inline const ::google::protobuf::RepeatedPtrField< $type$ >&\n"
|
||||
" $name$() const$deprecation$;\n"
|
||||
"inline ::google::protobuf::RepeatedPtrField< $type$ >*\n"
|
||||
" mutable_$name$()$deprecation$;\n");
|
||||
}
|
||||
|
||||
void RepeatedMessageFieldGenerator::
|
||||
GenerateInlineAccessorDefinitions(io::Printer* printer) const {
|
||||
printer->Print(variables_,
|
||||
"inline const $type$& $classname$::$name$(int index) const {\n"
|
||||
" return $name$_.Get(index);\n"
|
||||
"}\n"
|
||||
"inline $type$* $classname$::mutable_$name$(int index) {\n"
|
||||
" return $name$_.Mutable(index);\n"
|
||||
"}\n"
|
||||
"inline $type$* $classname$::add_$name$() {\n"
|
||||
" return $name$_.Add();\n"
|
||||
"}\n");
|
||||
printer->Print(variables_,
|
||||
"inline const ::google::protobuf::RepeatedPtrField< $type$ >&\n"
|
||||
"$classname$::$name$() const {\n"
|
||||
" return $name$_;\n"
|
||||
"}\n"
|
||||
"inline ::google::protobuf::RepeatedPtrField< $type$ >*\n"
|
||||
"$classname$::mutable_$name$() {\n"
|
||||
" return &$name$_;\n"
|
||||
"}\n");
|
||||
}
|
||||
|
||||
void RepeatedMessageFieldGenerator::
|
||||
GenerateClearingCode(io::Printer* printer) const {
|
||||
printer->Print(variables_, "$name$_.Clear();\n");
|
||||
}
|
||||
|
||||
void RepeatedMessageFieldGenerator::
|
||||
GenerateMergingCode(io::Printer* printer) const {
|
||||
printer->Print(variables_, "$name$_.MergeFrom(from.$name$_);\n");
|
||||
}
|
||||
|
||||
void RepeatedMessageFieldGenerator::
|
||||
GenerateSwappingCode(io::Printer* printer) const {
|
||||
printer->Print(variables_, "$name$_.Swap(&other->$name$_);\n");
|
||||
}
|
||||
|
||||
void RepeatedMessageFieldGenerator::
|
||||
GenerateConstructorCode(io::Printer* printer) const {
|
||||
// Not needed for repeated fields.
|
||||
}
|
||||
|
||||
void RepeatedMessageFieldGenerator::
|
||||
GenerateMergeFromCodedStream(io::Printer* printer) const {
|
||||
if (descriptor_->type() == FieldDescriptor::TYPE_MESSAGE) {
|
||||
printer->Print(variables_,
|
||||
"DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(\n"
|
||||
" input, add_$name$()));\n");
|
||||
} else {
|
||||
printer->Print(variables_,
|
||||
"DO_(::google::protobuf::internal::WireFormatLite::ReadGroupNoVirtual(\n"
|
||||
" $number$, input, add_$name$()));\n");
|
||||
}
|
||||
}
|
||||
|
||||
void RepeatedMessageFieldGenerator::
|
||||
GenerateSerializeWithCachedSizes(io::Printer* printer) const {
|
||||
printer->Print(variables_,
|
||||
"for (int i = 0; i < this->$name$_size(); i++) {\n"
|
||||
" ::google::protobuf::internal::WireFormatLite::Write$stream_writer$(\n"
|
||||
" $number$, this->$name$(i), output);\n"
|
||||
"}\n");
|
||||
}
|
||||
|
||||
void RepeatedMessageFieldGenerator::
|
||||
GenerateSerializeWithCachedSizesToArray(io::Printer* printer) const {
|
||||
printer->Print(variables_,
|
||||
"for (int i = 0; i < this->$name$_size(); i++) {\n"
|
||||
" target = ::google::protobuf::internal::WireFormatLite::\n"
|
||||
" Write$declared_type$NoVirtualToArray(\n"
|
||||
" $number$, this->$name$(i), target);\n"
|
||||
"}\n");
|
||||
}
|
||||
|
||||
void RepeatedMessageFieldGenerator::
|
||||
GenerateByteSize(io::Printer* printer) const {
|
||||
printer->Print(variables_,
|
||||
"total_size += $tag_size$ * this->$name$_size();\n"
|
||||
"for (int i = 0; i < this->$name$_size(); i++) {\n"
|
||||
" total_size +=\n"
|
||||
" ::google::protobuf::internal::WireFormatLite::$declared_type$SizeNoVirtual(\n"
|
||||
" this->$name$(i));\n"
|
||||
"}\n");
|
||||
}
|
||||
|
||||
} // namespace cpp
|
||||
} // namespace compiler
|
||||
} // namespace protobuf
|
||||
} // namespace google
|
||||
@ -1,102 +0,0 @@
|
||||
// Protocol Buffers - Google's data interchange format
|
||||
// Copyright 2008 Google Inc. All rights reserved.
|
||||
// http://code.google.com/p/protobuf/
|
||||
//
|
||||
// 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.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// 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.
|
||||
|
||||
// Author: kenton@google.com (Kenton Varda)
|
||||
// Based on original Protocol Buffers design by
|
||||
// Sanjay Ghemawat, Jeff Dean, and others.
|
||||
|
||||
#ifndef GOOGLE_PROTOBUF_COMPILER_CPP_MESSAGE_FIELD_H__
|
||||
#define GOOGLE_PROTOBUF_COMPILER_CPP_MESSAGE_FIELD_H__
|
||||
|
||||
#include <map>
|
||||
#include <string>
|
||||
#include <google/protobuf/compiler/cpp/cpp_field.h>
|
||||
|
||||
namespace google {
|
||||
namespace protobuf {
|
||||
namespace compiler {
|
||||
namespace cpp {
|
||||
|
||||
class MessageFieldGenerator : public FieldGenerator {
|
||||
public:
|
||||
explicit MessageFieldGenerator(const FieldDescriptor* descriptor);
|
||||
~MessageFieldGenerator();
|
||||
|
||||
// implements FieldGenerator ---------------------------------------
|
||||
void GeneratePrivateMembers(io::Printer* printer) const;
|
||||
void GenerateAccessorDeclarations(io::Printer* printer) const;
|
||||
void GenerateInlineAccessorDefinitions(io::Printer* printer) const;
|
||||
void GenerateClearingCode(io::Printer* printer) const;
|
||||
void GenerateMergingCode(io::Printer* printer) const;
|
||||
void GenerateSwappingCode(io::Printer* printer) const;
|
||||
void GenerateConstructorCode(io::Printer* printer) const;
|
||||
void GenerateMergeFromCodedStream(io::Printer* printer) const;
|
||||
void GenerateSerializeWithCachedSizes(io::Printer* printer) const;
|
||||
void GenerateSerializeWithCachedSizesToArray(io::Printer* printer) const;
|
||||
void GenerateByteSize(io::Printer* printer) const;
|
||||
|
||||
private:
|
||||
const FieldDescriptor* descriptor_;
|
||||
map<string, string> variables_;
|
||||
|
||||
GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(MessageFieldGenerator);
|
||||
};
|
||||
|
||||
class RepeatedMessageFieldGenerator : public FieldGenerator {
|
||||
public:
|
||||
explicit RepeatedMessageFieldGenerator(const FieldDescriptor* descriptor);
|
||||
~RepeatedMessageFieldGenerator();
|
||||
|
||||
// implements FieldGenerator ---------------------------------------
|
||||
void GeneratePrivateMembers(io::Printer* printer) const;
|
||||
void GenerateAccessorDeclarations(io::Printer* printer) const;
|
||||
void GenerateInlineAccessorDefinitions(io::Printer* printer) const;
|
||||
void GenerateClearingCode(io::Printer* printer) const;
|
||||
void GenerateMergingCode(io::Printer* printer) const;
|
||||
void GenerateSwappingCode(io::Printer* printer) const;
|
||||
void GenerateConstructorCode(io::Printer* printer) const;
|
||||
void GenerateMergeFromCodedStream(io::Printer* printer) const;
|
||||
void GenerateSerializeWithCachedSizes(io::Printer* printer) const;
|
||||
void GenerateSerializeWithCachedSizesToArray(io::Printer* printer) const;
|
||||
void GenerateByteSize(io::Printer* printer) const;
|
||||
|
||||
private:
|
||||
const FieldDescriptor* descriptor_;
|
||||
map<string, string> variables_;
|
||||
|
||||
GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(RepeatedMessageFieldGenerator);
|
||||
};
|
||||
|
||||
} // namespace cpp
|
||||
} // namespace compiler
|
||||
} // namespace protobuf
|
||||
|
||||
} // namespace google
|
||||
#endif // GOOGLE_PROTOBUF_COMPILER_CPP_MESSAGE_FIELD_H__
|
||||
@ -1,382 +0,0 @@
|
||||
// Protocol Buffers - Google's data interchange format
|
||||
// Copyright 2008 Google Inc. All rights reserved.
|
||||
// http://code.google.com/p/protobuf/
|
||||
//
|
||||
// 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.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// 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.
|
||||
|
||||
// Author: kenton@google.com (Kenton Varda)
|
||||
// Based on original Protocol Buffers design by
|
||||
// Sanjay Ghemawat, Jeff Dean, and others.
|
||||
|
||||
#include <google/protobuf/compiler/cpp/cpp_primitive_field.h>
|
||||
#include <google/protobuf/compiler/cpp/cpp_helpers.h>
|
||||
#include <google/protobuf/io/printer.h>
|
||||
#include <google/protobuf/wire_format.h>
|
||||
#include <google/protobuf/stubs/strutil.h>
|
||||
|
||||
namespace google {
|
||||
namespace protobuf {
|
||||
namespace compiler {
|
||||
namespace cpp {
|
||||
|
||||
using internal::WireFormatLite;
|
||||
|
||||
namespace {
|
||||
|
||||
// For encodings with fixed sizes, returns that size in bytes. Otherwise
|
||||
// returns -1.
|
||||
int FixedSize(FieldDescriptor::Type type) {
|
||||
switch (type) {
|
||||
case FieldDescriptor::TYPE_INT32 : return -1;
|
||||
case FieldDescriptor::TYPE_INT64 : return -1;
|
||||
case FieldDescriptor::TYPE_UINT32 : return -1;
|
||||
case FieldDescriptor::TYPE_UINT64 : return -1;
|
||||
case FieldDescriptor::TYPE_SINT32 : return -1;
|
||||
case FieldDescriptor::TYPE_SINT64 : return -1;
|
||||
case FieldDescriptor::TYPE_FIXED32 : return WireFormatLite::kFixed32Size;
|
||||
case FieldDescriptor::TYPE_FIXED64 : return WireFormatLite::kFixed64Size;
|
||||
case FieldDescriptor::TYPE_SFIXED32: return WireFormatLite::kSFixed32Size;
|
||||
case FieldDescriptor::TYPE_SFIXED64: return WireFormatLite::kSFixed64Size;
|
||||
case FieldDescriptor::TYPE_FLOAT : return WireFormatLite::kFloatSize;
|
||||
case FieldDescriptor::TYPE_DOUBLE : return WireFormatLite::kDoubleSize;
|
||||
|
||||
case FieldDescriptor::TYPE_BOOL : return WireFormatLite::kBoolSize;
|
||||
case FieldDescriptor::TYPE_ENUM : return -1;
|
||||
|
||||
case FieldDescriptor::TYPE_STRING : return -1;
|
||||
case FieldDescriptor::TYPE_BYTES : return -1;
|
||||
case FieldDescriptor::TYPE_GROUP : return -1;
|
||||
case FieldDescriptor::TYPE_MESSAGE : return -1;
|
||||
|
||||
// No default because we want the compiler to complain if any new
|
||||
// types are added.
|
||||
}
|
||||
GOOGLE_LOG(FATAL) << "Can't get here.";
|
||||
return -1;
|
||||
}
|
||||
|
||||
void SetPrimitiveVariables(const FieldDescriptor* descriptor,
|
||||
map<string, string>* variables) {
|
||||
SetCommonFieldVariables(descriptor, variables);
|
||||
(*variables)["type"] = PrimitiveTypeName(descriptor->cpp_type());
|
||||
(*variables)["default"] = DefaultValue(descriptor);
|
||||
(*variables)["tag"] = SimpleItoa(internal::WireFormat::MakeTag(descriptor));
|
||||
int fixed_size = FixedSize(descriptor->type());
|
||||
if (fixed_size != -1) {
|
||||
(*variables)["fixed_size"] = SimpleItoa(fixed_size);
|
||||
}
|
||||
(*variables)["wire_format_field_type"] =
|
||||
"::google::protobuf::internal::WireFormatLite::" + FieldDescriptorProto_Type_Name(
|
||||
static_cast<FieldDescriptorProto_Type>(descriptor->type()));
|
||||
}
|
||||
|
||||
} // namespace
|
||||
|
||||
// ===================================================================
|
||||
|
||||
PrimitiveFieldGenerator::
|
||||
PrimitiveFieldGenerator(const FieldDescriptor* descriptor)
|
||||
: descriptor_(descriptor) {
|
||||
SetPrimitiveVariables(descriptor, &variables_);
|
||||
}
|
||||
|
||||
PrimitiveFieldGenerator::~PrimitiveFieldGenerator() {}
|
||||
|
||||
void PrimitiveFieldGenerator::
|
||||
GeneratePrivateMembers(io::Printer* printer) const {
|
||||
printer->Print(variables_, "$type$ $name$_;\n");
|
||||
}
|
||||
|
||||
void PrimitiveFieldGenerator::
|
||||
GenerateAccessorDeclarations(io::Printer* printer) const {
|
||||
printer->Print(variables_,
|
||||
"inline $type$ $name$() const$deprecation$;\n"
|
||||
"inline void set_$name$($type$ value)$deprecation$;\n");
|
||||
}
|
||||
|
||||
void PrimitiveFieldGenerator::
|
||||
GenerateInlineAccessorDefinitions(io::Printer* printer) const {
|
||||
printer->Print(variables_,
|
||||
"inline $type$ $classname$::$name$() const {\n"
|
||||
" return $name$_;\n"
|
||||
"}\n"
|
||||
"inline void $classname$::set_$name$($type$ value) {\n"
|
||||
" set_has_$name$();\n"
|
||||
" $name$_ = value;\n"
|
||||
"}\n");
|
||||
}
|
||||
|
||||
void PrimitiveFieldGenerator::
|
||||
GenerateClearingCode(io::Printer* printer) const {
|
||||
printer->Print(variables_, "$name$_ = $default$;\n");
|
||||
}
|
||||
|
||||
void PrimitiveFieldGenerator::
|
||||
GenerateMergingCode(io::Printer* printer) const {
|
||||
printer->Print(variables_, "set_$name$(from.$name$());\n");
|
||||
}
|
||||
|
||||
void PrimitiveFieldGenerator::
|
||||
GenerateSwappingCode(io::Printer* printer) const {
|
||||
printer->Print(variables_, "std::swap($name$_, other->$name$_);\n");
|
||||
}
|
||||
|
||||
void PrimitiveFieldGenerator::
|
||||
GenerateConstructorCode(io::Printer* printer) const {
|
||||
printer->Print(variables_, "$name$_ = $default$;\n");
|
||||
}
|
||||
|
||||
void PrimitiveFieldGenerator::
|
||||
GenerateMergeFromCodedStream(io::Printer* printer) const {
|
||||
printer->Print(variables_,
|
||||
"DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<\n"
|
||||
" $type$, $wire_format_field_type$>(\n"
|
||||
" input, &$name$_)));\n"
|
||||
"set_has_$name$();\n");
|
||||
}
|
||||
|
||||
void PrimitiveFieldGenerator::
|
||||
GenerateSerializeWithCachedSizes(io::Printer* printer) const {
|
||||
printer->Print(variables_,
|
||||
"::google::protobuf::internal::WireFormatLite::Write$declared_type$("
|
||||
"$number$, this->$name$(), output);\n");
|
||||
}
|
||||
|
||||
void PrimitiveFieldGenerator::
|
||||
GenerateSerializeWithCachedSizesToArray(io::Printer* printer) const {
|
||||
printer->Print(variables_,
|
||||
"target = ::google::protobuf::internal::WireFormatLite::Write$declared_type$ToArray("
|
||||
"$number$, this->$name$(), target);\n");
|
||||
}
|
||||
|
||||
void PrimitiveFieldGenerator::
|
||||
GenerateByteSize(io::Printer* printer) const {
|
||||
int fixed_size = FixedSize(descriptor_->type());
|
||||
if (fixed_size == -1) {
|
||||
printer->Print(variables_,
|
||||
"total_size += $tag_size$ +\n"
|
||||
" ::google::protobuf::internal::WireFormatLite::$declared_type$Size(\n"
|
||||
" this->$name$());\n");
|
||||
} else {
|
||||
printer->Print(variables_,
|
||||
"total_size += $tag_size$ + $fixed_size$;\n");
|
||||
}
|
||||
}
|
||||
|
||||
// ===================================================================
|
||||
|
||||
RepeatedPrimitiveFieldGenerator::
|
||||
RepeatedPrimitiveFieldGenerator(const FieldDescriptor* descriptor)
|
||||
: descriptor_(descriptor) {
|
||||
SetPrimitiveVariables(descriptor, &variables_);
|
||||
|
||||
if (descriptor->options().packed()) {
|
||||
variables_["packed_reader"] = "ReadPackedPrimitive";
|
||||
variables_["repeated_reader"] = "ReadRepeatedPrimitiveNoInline";
|
||||
} else {
|
||||
variables_["packed_reader"] = "ReadPackedPrimitiveNoInline";
|
||||
variables_["repeated_reader"] = "ReadRepeatedPrimitive";
|
||||
}
|
||||
}
|
||||
|
||||
RepeatedPrimitiveFieldGenerator::~RepeatedPrimitiveFieldGenerator() {}
|
||||
|
||||
void RepeatedPrimitiveFieldGenerator::
|
||||
GeneratePrivateMembers(io::Printer* printer) const {
|
||||
printer->Print(variables_,
|
||||
"::google::protobuf::RepeatedField< $type$ > $name$_;\n");
|
||||
if (descriptor_->options().packed() && HasGeneratedMethods(descriptor_->file())) {
|
||||
printer->Print(variables_,
|
||||
"mutable int _$name$_cached_byte_size_;\n");
|
||||
}
|
||||
}
|
||||
|
||||
void RepeatedPrimitiveFieldGenerator::
|
||||
GenerateAccessorDeclarations(io::Printer* printer) const {
|
||||
printer->Print(variables_,
|
||||
"inline $type$ $name$(int index) const$deprecation$;\n"
|
||||
"inline void set_$name$(int index, $type$ value)$deprecation$;\n"
|
||||
"inline void add_$name$($type$ value)$deprecation$;\n");
|
||||
printer->Print(variables_,
|
||||
"inline const ::google::protobuf::RepeatedField< $type$ >&\n"
|
||||
" $name$() const$deprecation$;\n"
|
||||
"inline ::google::protobuf::RepeatedField< $type$ >*\n"
|
||||
" mutable_$name$()$deprecation$;\n");
|
||||
}
|
||||
|
||||
void RepeatedPrimitiveFieldGenerator::
|
||||
GenerateInlineAccessorDefinitions(io::Printer* printer) const {
|
||||
printer->Print(variables_,
|
||||
"inline $type$ $classname$::$name$(int index) const {\n"
|
||||
" return $name$_.Get(index);\n"
|
||||
"}\n"
|
||||
"inline void $classname$::set_$name$(int index, $type$ value) {\n"
|
||||
" $name$_.Set(index, value);\n"
|
||||
"}\n"
|
||||
"inline void $classname$::add_$name$($type$ value) {\n"
|
||||
" $name$_.Add(value);\n"
|
||||
"}\n");
|
||||
printer->Print(variables_,
|
||||
"inline const ::google::protobuf::RepeatedField< $type$ >&\n"
|
||||
"$classname$::$name$() const {\n"
|
||||
" return $name$_;\n"
|
||||
"}\n"
|
||||
"inline ::google::protobuf::RepeatedField< $type$ >*\n"
|
||||
"$classname$::mutable_$name$() {\n"
|
||||
" return &$name$_;\n"
|
||||
"}\n");
|
||||
}
|
||||
|
||||
void RepeatedPrimitiveFieldGenerator::
|
||||
GenerateClearingCode(io::Printer* printer) const {
|
||||
printer->Print(variables_, "$name$_.Clear();\n");
|
||||
}
|
||||
|
||||
void RepeatedPrimitiveFieldGenerator::
|
||||
GenerateMergingCode(io::Printer* printer) const {
|
||||
printer->Print(variables_, "$name$_.MergeFrom(from.$name$_);\n");
|
||||
}
|
||||
|
||||
void RepeatedPrimitiveFieldGenerator::
|
||||
GenerateSwappingCode(io::Printer* printer) const {
|
||||
printer->Print(variables_, "$name$_.Swap(&other->$name$_);\n");
|
||||
}
|
||||
|
||||
void RepeatedPrimitiveFieldGenerator::
|
||||
GenerateConstructorCode(io::Printer* printer) const {
|
||||
// Not needed for repeated fields.
|
||||
}
|
||||
|
||||
void RepeatedPrimitiveFieldGenerator::
|
||||
GenerateMergeFromCodedStream(io::Printer* printer) const {
|
||||
printer->Print(variables_,
|
||||
"DO_((::google::protobuf::internal::WireFormatLite::$repeated_reader$<\n"
|
||||
" $type$, $wire_format_field_type$>(\n"
|
||||
" $tag_size$, $tag$, input, this->mutable_$name$())));\n");
|
||||
}
|
||||
|
||||
void RepeatedPrimitiveFieldGenerator::
|
||||
GenerateMergeFromCodedStreamWithPacking(io::Printer* printer) const {
|
||||
printer->Print(variables_,
|
||||
"DO_((::google::protobuf::internal::WireFormatLite::$packed_reader$<\n"
|
||||
" $type$, $wire_format_field_type$>(\n"
|
||||
" input, this->mutable_$name$())));\n");
|
||||
}
|
||||
|
||||
void RepeatedPrimitiveFieldGenerator::
|
||||
GenerateSerializeWithCachedSizes(io::Printer* printer) const {
|
||||
if (descriptor_->options().packed()) {
|
||||
// Write the tag and the size.
|
||||
printer->Print(variables_,
|
||||
"if (this->$name$_size() > 0) {\n"
|
||||
" ::google::protobuf::internal::WireFormatLite::WriteTag("
|
||||
"$number$, "
|
||||
"::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, "
|
||||
"output);\n"
|
||||
" output->WriteVarint32(_$name$_cached_byte_size_);\n"
|
||||
"}\n");
|
||||
}
|
||||
printer->Print(variables_,
|
||||
"for (int i = 0; i < this->$name$_size(); i++) {\n");
|
||||
if (descriptor_->options().packed()) {
|
||||
printer->Print(variables_,
|
||||
" ::google::protobuf::internal::WireFormatLite::Write$declared_type$NoTag(\n"
|
||||
" this->$name$(i), output);\n");
|
||||
} else {
|
||||
printer->Print(variables_,
|
||||
" ::google::protobuf::internal::WireFormatLite::Write$declared_type$(\n"
|
||||
" $number$, this->$name$(i), output);\n");
|
||||
}
|
||||
printer->Print("}\n");
|
||||
}
|
||||
|
||||
void RepeatedPrimitiveFieldGenerator::
|
||||
GenerateSerializeWithCachedSizesToArray(io::Printer* printer) const {
|
||||
if (descriptor_->options().packed()) {
|
||||
// Write the tag and the size.
|
||||
printer->Print(variables_,
|
||||
"if (this->$name$_size() > 0) {\n"
|
||||
" target = ::google::protobuf::internal::WireFormatLite::WriteTagToArray(\n"
|
||||
" $number$,\n"
|
||||
" ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED,\n"
|
||||
" target);\n"
|
||||
" target = ::google::protobuf::io::CodedOutputStream::WriteVarint32ToArray(\n"
|
||||
" _$name$_cached_byte_size_, target);\n"
|
||||
"}\n");
|
||||
}
|
||||
printer->Print(variables_,
|
||||
"for (int i = 0; i < this->$name$_size(); i++) {\n");
|
||||
if (descriptor_->options().packed()) {
|
||||
printer->Print(variables_,
|
||||
" target = ::google::protobuf::internal::WireFormatLite::\n"
|
||||
" Write$declared_type$NoTagToArray(this->$name$(i), target);\n");
|
||||
} else {
|
||||
printer->Print(variables_,
|
||||
" target = ::google::protobuf::internal::WireFormatLite::\n"
|
||||
" Write$declared_type$ToArray($number$, this->$name$(i), target);\n");
|
||||
}
|
||||
printer->Print("}\n");
|
||||
}
|
||||
|
||||
void RepeatedPrimitiveFieldGenerator::
|
||||
GenerateByteSize(io::Printer* printer) const {
|
||||
printer->Print(variables_,
|
||||
"{\n"
|
||||
" int data_size = 0;\n");
|
||||
printer->Indent();
|
||||
int fixed_size = FixedSize(descriptor_->type());
|
||||
if (fixed_size == -1) {
|
||||
printer->Print(variables_,
|
||||
"for (int i = 0; i < this->$name$_size(); i++) {\n"
|
||||
" data_size += ::google::protobuf::internal::WireFormatLite::\n"
|
||||
" $declared_type$Size(this->$name$(i));\n"
|
||||
"}\n");
|
||||
} else {
|
||||
printer->Print(variables_,
|
||||
"data_size = $fixed_size$ * this->$name$_size();\n");
|
||||
}
|
||||
|
||||
if (descriptor_->options().packed()) {
|
||||
printer->Print(variables_,
|
||||
"if (data_size > 0) {\n"
|
||||
" total_size += $tag_size$ +\n"
|
||||
" ::google::protobuf::internal::WireFormatLite::Int32Size(data_size);\n"
|
||||
"}\n"
|
||||
"_$name$_cached_byte_size_ = data_size;\n"
|
||||
"total_size += data_size;\n");
|
||||
} else {
|
||||
printer->Print(variables_,
|
||||
"total_size += $tag_size$ * this->$name$_size() + data_size;\n");
|
||||
}
|
||||
printer->Outdent();
|
||||
printer->Print("}\n");
|
||||
}
|
||||
|
||||
} // namespace cpp
|
||||
} // namespace compiler
|
||||
} // namespace protobuf
|
||||
} // namespace google
|
||||
@ -1,103 +0,0 @@
|
||||
// Protocol Buffers - Google's data interchange format
|
||||
// Copyright 2008 Google Inc. All rights reserved.
|
||||
// http://code.google.com/p/protobuf/
|
||||
//
|
||||
// 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.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// 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.
|
||||
|
||||
// Author: kenton@google.com (Kenton Varda)
|
||||
// Based on original Protocol Buffers design by
|
||||
// Sanjay Ghemawat, Jeff Dean, and others.
|
||||
|
||||
#ifndef GOOGLE_PROTOBUF_COMPILER_CPP_PRIMITIVE_FIELD_H__
|
||||
#define GOOGLE_PROTOBUF_COMPILER_CPP_PRIMITIVE_FIELD_H__
|
||||
|
||||
#include <map>
|
||||
#include <string>
|
||||
#include <google/protobuf/compiler/cpp/cpp_field.h>
|
||||
|
||||
namespace google {
|
||||
namespace protobuf {
|
||||
namespace compiler {
|
||||
namespace cpp {
|
||||
|
||||
class PrimitiveFieldGenerator : public FieldGenerator {
|
||||
public:
|
||||
explicit PrimitiveFieldGenerator(const FieldDescriptor* descriptor);
|
||||
~PrimitiveFieldGenerator();
|
||||
|
||||
// implements FieldGenerator ---------------------------------------
|
||||
void GeneratePrivateMembers(io::Printer* printer) const;
|
||||
void GenerateAccessorDeclarations(io::Printer* printer) const;
|
||||
void GenerateInlineAccessorDefinitions(io::Printer* printer) const;
|
||||
void GenerateClearingCode(io::Printer* printer) const;
|
||||
void GenerateMergingCode(io::Printer* printer) const;
|
||||
void GenerateSwappingCode(io::Printer* printer) const;
|
||||
void GenerateConstructorCode(io::Printer* printer) const;
|
||||
void GenerateMergeFromCodedStream(io::Printer* printer) const;
|
||||
void GenerateSerializeWithCachedSizes(io::Printer* printer) const;
|
||||
void GenerateSerializeWithCachedSizesToArray(io::Printer* printer) const;
|
||||
void GenerateByteSize(io::Printer* printer) const;
|
||||
|
||||
private:
|
||||
const FieldDescriptor* descriptor_;
|
||||
map<string, string> variables_;
|
||||
|
||||
GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(PrimitiveFieldGenerator);
|
||||
};
|
||||
|
||||
class RepeatedPrimitiveFieldGenerator : public FieldGenerator {
|
||||
public:
|
||||
explicit RepeatedPrimitiveFieldGenerator(const FieldDescriptor* descriptor);
|
||||
~RepeatedPrimitiveFieldGenerator();
|
||||
|
||||
// implements FieldGenerator ---------------------------------------
|
||||
void GeneratePrivateMembers(io::Printer* printer) const;
|
||||
void GenerateAccessorDeclarations(io::Printer* printer) const;
|
||||
void GenerateInlineAccessorDefinitions(io::Printer* printer) const;
|
||||
void GenerateClearingCode(io::Printer* printer) const;
|
||||
void GenerateMergingCode(io::Printer* printer) const;
|
||||
void GenerateSwappingCode(io::Printer* printer) const;
|
||||
void GenerateConstructorCode(io::Printer* printer) const;
|
||||
void GenerateMergeFromCodedStream(io::Printer* printer) const;
|
||||
void GenerateMergeFromCodedStreamWithPacking(io::Printer* printer) const;
|
||||
void GenerateSerializeWithCachedSizes(io::Printer* printer) const;
|
||||
void GenerateSerializeWithCachedSizesToArray(io::Printer* printer) const;
|
||||
void GenerateByteSize(io::Printer* printer) const;
|
||||
|
||||
private:
|
||||
const FieldDescriptor* descriptor_;
|
||||
map<string, string> variables_;
|
||||
|
||||
GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(RepeatedPrimitiveFieldGenerator);
|
||||
};
|
||||
|
||||
} // namespace cpp
|
||||
} // namespace compiler
|
||||
} // namespace protobuf
|
||||
|
||||
} // namespace google
|
||||
#endif // GOOGLE_PROTOBUF_COMPILER_CPP_PRIMITIVE_FIELD_H__
|
||||
@ -1,334 +0,0 @@
|
||||
// Protocol Buffers - Google's data interchange format
|
||||
// Copyright 2008 Google Inc. All rights reserved.
|
||||
// http://code.google.com/p/protobuf/
|
||||
//
|
||||
// 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.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// 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.
|
||||
|
||||
// Author: kenton@google.com (Kenton Varda)
|
||||
// Based on original Protocol Buffers design by
|
||||
// Sanjay Ghemawat, Jeff Dean, and others.
|
||||
|
||||
#include <google/protobuf/compiler/cpp/cpp_service.h>
|
||||
#include <google/protobuf/compiler/cpp/cpp_helpers.h>
|
||||
#include <google/protobuf/io/printer.h>
|
||||
#include <google/protobuf/stubs/strutil.h>
|
||||
|
||||
namespace google {
|
||||
namespace protobuf {
|
||||
namespace compiler {
|
||||
namespace cpp {
|
||||
|
||||
ServiceGenerator::ServiceGenerator(const ServiceDescriptor* descriptor,
|
||||
const string& dllexport_decl)
|
||||
: descriptor_(descriptor) {
|
||||
vars_["classname"] = descriptor_->name();
|
||||
vars_["full_name"] = descriptor_->full_name();
|
||||
if (dllexport_decl.empty()) {
|
||||
vars_["dllexport"] = "";
|
||||
} else {
|
||||
vars_["dllexport"] = dllexport_decl + " ";
|
||||
}
|
||||
}
|
||||
|
||||
ServiceGenerator::~ServiceGenerator() {}
|
||||
|
||||
void ServiceGenerator::GenerateDeclarations(io::Printer* printer) {
|
||||
// Forward-declare the stub type.
|
||||
printer->Print(vars_,
|
||||
"class $classname$_Stub;\n"
|
||||
"\n");
|
||||
|
||||
GenerateInterface(printer);
|
||||
GenerateStubDefinition(printer);
|
||||
}
|
||||
|
||||
void ServiceGenerator::GenerateInterface(io::Printer* printer) {
|
||||
printer->Print(vars_,
|
||||
"class $dllexport$$classname$ : public ::google::protobuf::Service {\n"
|
||||
" protected:\n"
|
||||
" // This class should be treated as an abstract interface.\n"
|
||||
" inline $classname$() {};\n"
|
||||
" public:\n"
|
||||
" virtual ~$classname$();\n");
|
||||
printer->Indent();
|
||||
|
||||
printer->Print(vars_,
|
||||
"\n"
|
||||
"typedef $classname$_Stub Stub;\n"
|
||||
"\n"
|
||||
"static const ::google::protobuf::ServiceDescriptor* descriptor();\n"
|
||||
"\n");
|
||||
|
||||
GenerateMethodSignatures(VIRTUAL, printer);
|
||||
|
||||
printer->Print(
|
||||
"\n"
|
||||
"// implements Service ----------------------------------------------\n"
|
||||
"\n"
|
||||
"const ::google::protobuf::ServiceDescriptor* GetDescriptor();\n"
|
||||
"void CallMethod(const ::google::protobuf::MethodDescriptor* method,\n"
|
||||
" ::google::protobuf::RpcController* controller,\n"
|
||||
" const ::google::protobuf::Message* request,\n"
|
||||
" ::google::protobuf::Message* response,\n"
|
||||
" ::google::protobuf::Closure* done);\n"
|
||||
"const ::google::protobuf::Message& GetRequestPrototype(\n"
|
||||
" const ::google::protobuf::MethodDescriptor* method) const;\n"
|
||||
"const ::google::protobuf::Message& GetResponsePrototype(\n"
|
||||
" const ::google::protobuf::MethodDescriptor* method) const;\n");
|
||||
|
||||
printer->Outdent();
|
||||
printer->Print(vars_,
|
||||
"\n"
|
||||
" private:\n"
|
||||
" GOOGLE_DISALLOW_EVIL_CONSTRUCTORS($classname$);\n"
|
||||
"};\n"
|
||||
"\n");
|
||||
}
|
||||
|
||||
void ServiceGenerator::GenerateStubDefinition(io::Printer* printer) {
|
||||
printer->Print(vars_,
|
||||
"class $dllexport$$classname$_Stub : public $classname$ {\n"
|
||||
" public:\n");
|
||||
|
||||
printer->Indent();
|
||||
|
||||
printer->Print(vars_,
|
||||
"$classname$_Stub(::google::protobuf::RpcChannel* channel);\n"
|
||||
"$classname$_Stub(::google::protobuf::RpcChannel* channel,\n"
|
||||
" ::google::protobuf::Service::ChannelOwnership ownership);\n"
|
||||
"~$classname$_Stub();\n"
|
||||
"\n"
|
||||
"inline ::google::protobuf::RpcChannel* channel() { return channel_; }\n"
|
||||
"\n"
|
||||
"// implements $classname$ ------------------------------------------\n"
|
||||
"\n");
|
||||
|
||||
GenerateMethodSignatures(NON_VIRTUAL, printer);
|
||||
|
||||
printer->Outdent();
|
||||
printer->Print(vars_,
|
||||
" private:\n"
|
||||
" ::google::protobuf::RpcChannel* channel_;\n"
|
||||
" bool owns_channel_;\n"
|
||||
" GOOGLE_DISALLOW_EVIL_CONSTRUCTORS($classname$_Stub);\n"
|
||||
"};\n"
|
||||
"\n");
|
||||
}
|
||||
|
||||
void ServiceGenerator::GenerateMethodSignatures(
|
||||
VirtualOrNon virtual_or_non, io::Printer* printer) {
|
||||
for (int i = 0; i < descriptor_->method_count(); i++) {
|
||||
const MethodDescriptor* method = descriptor_->method(i);
|
||||
map<string, string> sub_vars;
|
||||
sub_vars["name"] = method->name();
|
||||
sub_vars["input_type"] = ClassName(method->input_type(), true);
|
||||
sub_vars["output_type"] = ClassName(method->output_type(), true);
|
||||
sub_vars["virtual"] = virtual_or_non == VIRTUAL ? "virtual " : "";
|
||||
|
||||
printer->Print(sub_vars,
|
||||
"$virtual$void $name$(::google::protobuf::RpcController* controller,\n"
|
||||
" const $input_type$* request,\n"
|
||||
" $output_type$* response,\n"
|
||||
" ::google::protobuf::Closure* done);\n");
|
||||
}
|
||||
}
|
||||
|
||||
// ===================================================================
|
||||
|
||||
void ServiceGenerator::GenerateDescriptorInitializer(
|
||||
io::Printer* printer, int index) {
|
||||
map<string, string> vars;
|
||||
vars["classname"] = descriptor_->name();
|
||||
vars["index"] = SimpleItoa(index);
|
||||
|
||||
printer->Print(vars,
|
||||
"$classname$_descriptor_ = file->service($index$);\n");
|
||||
}
|
||||
|
||||
// ===================================================================
|
||||
|
||||
void ServiceGenerator::GenerateImplementation(io::Printer* printer) {
|
||||
printer->Print(vars_,
|
||||
"$classname$::~$classname$() {}\n"
|
||||
"\n"
|
||||
"const ::google::protobuf::ServiceDescriptor* $classname$::descriptor() {\n"
|
||||
" protobuf_AssignDescriptorsOnce();\n"
|
||||
" return $classname$_descriptor_;\n"
|
||||
"}\n"
|
||||
"\n"
|
||||
"const ::google::protobuf::ServiceDescriptor* $classname$::GetDescriptor() {\n"
|
||||
" protobuf_AssignDescriptorsOnce();\n"
|
||||
" return $classname$_descriptor_;\n"
|
||||
"}\n"
|
||||
"\n");
|
||||
|
||||
// Generate methods of the interface.
|
||||
GenerateNotImplementedMethods(printer);
|
||||
GenerateCallMethod(printer);
|
||||
GenerateGetPrototype(REQUEST, printer);
|
||||
GenerateGetPrototype(RESPONSE, printer);
|
||||
|
||||
// Generate stub implementation.
|
||||
printer->Print(vars_,
|
||||
"$classname$_Stub::$classname$_Stub(::google::protobuf::RpcChannel* channel)\n"
|
||||
" : channel_(channel), owns_channel_(false) {}\n"
|
||||
"$classname$_Stub::$classname$_Stub(\n"
|
||||
" ::google::protobuf::RpcChannel* channel,\n"
|
||||
" ::google::protobuf::Service::ChannelOwnership ownership)\n"
|
||||
" : channel_(channel),\n"
|
||||
" owns_channel_(ownership == ::google::protobuf::Service::STUB_OWNS_CHANNEL) {}\n"
|
||||
"$classname$_Stub::~$classname$_Stub() {\n"
|
||||
" if (owns_channel_) delete channel_;\n"
|
||||
"}\n"
|
||||
"\n");
|
||||
|
||||
GenerateStubMethods(printer);
|
||||
}
|
||||
|
||||
void ServiceGenerator::GenerateNotImplementedMethods(io::Printer* printer) {
|
||||
for (int i = 0; i < descriptor_->method_count(); i++) {
|
||||
const MethodDescriptor* method = descriptor_->method(i);
|
||||
map<string, string> sub_vars;
|
||||
sub_vars["classname"] = descriptor_->name();
|
||||
sub_vars["name"] = method->name();
|
||||
sub_vars["index"] = SimpleItoa(i);
|
||||
sub_vars["input_type"] = ClassName(method->input_type(), true);
|
||||
sub_vars["output_type"] = ClassName(method->output_type(), true);
|
||||
|
||||
printer->Print(sub_vars,
|
||||
"void $classname$::$name$(::google::protobuf::RpcController* controller,\n"
|
||||
" const $input_type$*,\n"
|
||||
" $output_type$*,\n"
|
||||
" ::google::protobuf::Closure* done) {\n"
|
||||
" controller->SetFailed(\"Method $name$() not implemented.\");\n"
|
||||
" done->Run();\n"
|
||||
"}\n"
|
||||
"\n");
|
||||
}
|
||||
}
|
||||
|
||||
void ServiceGenerator::GenerateCallMethod(io::Printer* printer) {
|
||||
printer->Print(vars_,
|
||||
"void $classname$::CallMethod(const ::google::protobuf::MethodDescriptor* method,\n"
|
||||
" ::google::protobuf::RpcController* controller,\n"
|
||||
" const ::google::protobuf::Message* request,\n"
|
||||
" ::google::protobuf::Message* response,\n"
|
||||
" ::google::protobuf::Closure* done) {\n"
|
||||
" GOOGLE_DCHECK_EQ(method->service(), $classname$_descriptor_);\n"
|
||||
" switch(method->index()) {\n");
|
||||
|
||||
for (int i = 0; i < descriptor_->method_count(); i++) {
|
||||
const MethodDescriptor* method = descriptor_->method(i);
|
||||
map<string, string> sub_vars;
|
||||
sub_vars["name"] = method->name();
|
||||
sub_vars["index"] = SimpleItoa(i);
|
||||
sub_vars["input_type"] = ClassName(method->input_type(), true);
|
||||
sub_vars["output_type"] = ClassName(method->output_type(), true);
|
||||
|
||||
// Note: down_cast does not work here because it only works on pointers,
|
||||
// not references.
|
||||
printer->Print(sub_vars,
|
||||
" case $index$:\n"
|
||||
" $name$(controller,\n"
|
||||
" ::google::protobuf::down_cast<const $input_type$*>(request),\n"
|
||||
" ::google::protobuf::down_cast< $output_type$*>(response),\n"
|
||||
" done);\n"
|
||||
" break;\n");
|
||||
}
|
||||
|
||||
printer->Print(vars_,
|
||||
" default:\n"
|
||||
" GOOGLE_LOG(FATAL) << \"Bad method index; this should never happen.\";\n"
|
||||
" break;\n"
|
||||
" }\n"
|
||||
"}\n"
|
||||
"\n");
|
||||
}
|
||||
|
||||
void ServiceGenerator::GenerateGetPrototype(RequestOrResponse which,
|
||||
io::Printer* printer) {
|
||||
if (which == REQUEST) {
|
||||
printer->Print(vars_,
|
||||
"const ::google::protobuf::Message& $classname$::GetRequestPrototype(\n");
|
||||
} else {
|
||||
printer->Print(vars_,
|
||||
"const ::google::protobuf::Message& $classname$::GetResponsePrototype(\n");
|
||||
}
|
||||
|
||||
printer->Print(vars_,
|
||||
" const ::google::protobuf::MethodDescriptor* method) const {\n"
|
||||
" GOOGLE_DCHECK_EQ(method->service(), descriptor());\n"
|
||||
" switch(method->index()) {\n");
|
||||
|
||||
for (int i = 0; i < descriptor_->method_count(); i++) {
|
||||
const MethodDescriptor* method = descriptor_->method(i);
|
||||
const Descriptor* type =
|
||||
(which == REQUEST) ? method->input_type() : method->output_type();
|
||||
|
||||
map<string, string> sub_vars;
|
||||
sub_vars["index"] = SimpleItoa(i);
|
||||
sub_vars["type"] = ClassName(type, true);
|
||||
|
||||
printer->Print(sub_vars,
|
||||
" case $index$:\n"
|
||||
" return $type$::default_instance();\n");
|
||||
}
|
||||
|
||||
printer->Print(vars_,
|
||||
" default:\n"
|
||||
" GOOGLE_LOG(FATAL) << \"Bad method index; this should never happen.\";\n"
|
||||
" return *reinterpret_cast< ::google::protobuf::Message*>(NULL);\n"
|
||||
" }\n"
|
||||
"}\n"
|
||||
"\n");
|
||||
}
|
||||
|
||||
void ServiceGenerator::GenerateStubMethods(io::Printer* printer) {
|
||||
for (int i = 0; i < descriptor_->method_count(); i++) {
|
||||
const MethodDescriptor* method = descriptor_->method(i);
|
||||
map<string, string> sub_vars;
|
||||
sub_vars["classname"] = descriptor_->name();
|
||||
sub_vars["name"] = method->name();
|
||||
sub_vars["index"] = SimpleItoa(i);
|
||||
sub_vars["input_type"] = ClassName(method->input_type(), true);
|
||||
sub_vars["output_type"] = ClassName(method->output_type(), true);
|
||||
|
||||
printer->Print(sub_vars,
|
||||
"void $classname$_Stub::$name$(::google::protobuf::RpcController* controller,\n"
|
||||
" const $input_type$* request,\n"
|
||||
" $output_type$* response,\n"
|
||||
" ::google::protobuf::Closure* done) {\n"
|
||||
" channel_->CallMethod(descriptor()->method($index$),\n"
|
||||
" controller, request, response, done);\n"
|
||||
"}\n");
|
||||
}
|
||||
}
|
||||
|
||||
} // namespace cpp
|
||||
} // namespace compiler
|
||||
} // namespace protobuf
|
||||
} // namespace google
|
||||
@ -1,453 +0,0 @@
|
||||
// Protocol Buffers - Google's data interchange format
|
||||
// Copyright 2008 Google Inc. All rights reserved.
|
||||
// http://code.google.com/p/protobuf/
|
||||
//
|
||||
// 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.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// 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.
|
||||
|
||||
// Author: kenton@google.com (Kenton Varda)
|
||||
// Based on original Protocol Buffers design by
|
||||
// Sanjay Ghemawat, Jeff Dean, and others.
|
||||
|
||||
#include <google/protobuf/compiler/cpp/cpp_string_field.h>
|
||||
#include <google/protobuf/compiler/cpp/cpp_helpers.h>
|
||||
#include <google/protobuf/io/printer.h>
|
||||
#include <google/protobuf/descriptor.pb.h>
|
||||
#include <google/protobuf/stubs/strutil.h>
|
||||
|
||||
namespace google {
|
||||
namespace protobuf {
|
||||
namespace compiler {
|
||||
namespace cpp {
|
||||
|
||||
namespace {
|
||||
|
||||
void SetStringVariables(const FieldDescriptor* descriptor,
|
||||
map<string, string>* variables) {
|
||||
SetCommonFieldVariables(descriptor, variables);
|
||||
(*variables)["default"] = DefaultValue(descriptor);
|
||||
(*variables)["default_variable"] = descriptor->default_value_string().empty()
|
||||
? "::google::protobuf::internal::kEmptyString"
|
||||
: "_default_" + FieldName(descriptor) + "_";
|
||||
(*variables)["pointer_type"] =
|
||||
descriptor->type() == FieldDescriptor::TYPE_BYTES ? "void" : "char";
|
||||
}
|
||||
|
||||
} // namespace
|
||||
|
||||
// ===================================================================
|
||||
|
||||
StringFieldGenerator::
|
||||
StringFieldGenerator(const FieldDescriptor* descriptor)
|
||||
: descriptor_(descriptor) {
|
||||
SetStringVariables(descriptor, &variables_);
|
||||
}
|
||||
|
||||
StringFieldGenerator::~StringFieldGenerator() {}
|
||||
|
||||
void StringFieldGenerator::
|
||||
GeneratePrivateMembers(io::Printer* printer) const {
|
||||
printer->Print(variables_, "::std::string* $name$_;\n");
|
||||
if (!descriptor_->default_value_string().empty()) {
|
||||
printer->Print(variables_, "static const ::std::string $default_variable$;\n");
|
||||
}
|
||||
}
|
||||
|
||||
void StringFieldGenerator::
|
||||
GenerateAccessorDeclarations(io::Printer* printer) const {
|
||||
// If we're using StringFieldGenerator for a field with a ctype, it's
|
||||
// because that ctype isn't actually implemented. In particular, this is
|
||||
// true of ctype=CORD and ctype=STRING_PIECE in the open source release.
|
||||
// We aren't releasing Cord because it has too many Google-specific
|
||||
// dependencies and we aren't releasing StringPiece because it's hardly
|
||||
// useful outside of Google and because it would get confusing to have
|
||||
// multiple instances of the StringPiece class in different libraries (PCRE
|
||||
// already includes it for their C++ bindings, which came from Google).
|
||||
//
|
||||
// In any case, we make all the accessors private while still actually
|
||||
// using a string to represent the field internally. This way, we can
|
||||
// guarantee that if we do ever implement the ctype, it won't break any
|
||||
// existing users who might be -- for whatever reason -- already using .proto
|
||||
// files that applied the ctype. The field can still be accessed via the
|
||||
// reflection interface since the reflection interface is independent of
|
||||
// the string's underlying representation.
|
||||
if (descriptor_->options().ctype() != FieldOptions::STRING) {
|
||||
printer->Outdent();
|
||||
printer->Print(
|
||||
" private:\n"
|
||||
" // Hidden due to unknown ctype option.\n");
|
||||
printer->Indent();
|
||||
}
|
||||
|
||||
printer->Print(variables_,
|
||||
"inline const ::std::string& $name$() const$deprecation$;\n"
|
||||
"inline void set_$name$(const ::std::string& value)$deprecation$;\n"
|
||||
"inline void set_$name$(const char* value)$deprecation$;\n"
|
||||
"inline void set_$name$(const $pointer_type$* value, size_t size)"
|
||||
"$deprecation$;\n"
|
||||
"inline ::std::string* mutable_$name$()$deprecation$;\n"
|
||||
"inline ::std::string* release_$name$()$deprecation$;\n");
|
||||
|
||||
if (descriptor_->options().ctype() != FieldOptions::STRING) {
|
||||
printer->Outdent();
|
||||
printer->Print(" public:\n");
|
||||
printer->Indent();
|
||||
}
|
||||
}
|
||||
|
||||
void StringFieldGenerator::
|
||||
GenerateInlineAccessorDefinitions(io::Printer* printer) const {
|
||||
printer->Print(variables_,
|
||||
"inline const ::std::string& $classname$::$name$() const {\n"
|
||||
" return *$name$_;\n"
|
||||
"}\n"
|
||||
"inline void $classname$::set_$name$(const ::std::string& value) {\n"
|
||||
" set_has_$name$();\n"
|
||||
" if ($name$_ == &$default_variable$) {\n"
|
||||
" $name$_ = new ::std::string;\n"
|
||||
" }\n"
|
||||
" $name$_->assign(value);\n"
|
||||
"}\n"
|
||||
"inline void $classname$::set_$name$(const char* value) {\n"
|
||||
" set_has_$name$();\n"
|
||||
" if ($name$_ == &$default_variable$) {\n"
|
||||
" $name$_ = new ::std::string;\n"
|
||||
" }\n"
|
||||
" $name$_->assign(value);\n"
|
||||
"}\n"
|
||||
"inline "
|
||||
"void $classname$::set_$name$(const $pointer_type$* value, size_t size) {\n"
|
||||
" set_has_$name$();\n"
|
||||
" if ($name$_ == &$default_variable$) {\n"
|
||||
" $name$_ = new ::std::string;\n"
|
||||
" }\n"
|
||||
" $name$_->assign(reinterpret_cast<const char*>(value), size);\n"
|
||||
"}\n"
|
||||
"inline ::std::string* $classname$::mutable_$name$() {\n"
|
||||
" set_has_$name$();\n"
|
||||
" if ($name$_ == &$default_variable$) {\n");
|
||||
if (descriptor_->default_value_string().empty()) {
|
||||
printer->Print(variables_,
|
||||
" $name$_ = new ::std::string;\n");
|
||||
} else {
|
||||
printer->Print(variables_,
|
||||
" $name$_ = new ::std::string($default_variable$);\n");
|
||||
}
|
||||
printer->Print(variables_,
|
||||
" }\n"
|
||||
" return $name$_;\n"
|
||||
"}\n"
|
||||
"inline ::std::string* $classname$::release_$name$() {\n"
|
||||
" clear_has_$name$();\n"
|
||||
" if ($name$_ == &$default_variable$) {\n"
|
||||
" return NULL;\n"
|
||||
" } else {\n"
|
||||
" ::std::string* temp = $name$_;\n"
|
||||
" $name$_ = const_cast< ::std::string*>(&$default_variable$);\n"
|
||||
" return temp;\n"
|
||||
" }\n"
|
||||
"}\n");
|
||||
}
|
||||
|
||||
void StringFieldGenerator::
|
||||
GenerateNonInlineAccessorDefinitions(io::Printer* printer) const {
|
||||
if (!descriptor_->default_value_string().empty()) {
|
||||
printer->Print(variables_,
|
||||
"const ::std::string $classname$::$default_variable$($default$);\n");
|
||||
}
|
||||
}
|
||||
|
||||
void StringFieldGenerator::
|
||||
GenerateClearingCode(io::Printer* printer) const {
|
||||
if (descriptor_->default_value_string().empty()) {
|
||||
printer->Print(variables_,
|
||||
"if ($name$_ != &$default_variable$) {\n"
|
||||
" $name$_->clear();\n"
|
||||
"}\n");
|
||||
} else {
|
||||
printer->Print(variables_,
|
||||
"if ($name$_ != &$default_variable$) {\n"
|
||||
" $name$_->assign($default_variable$);\n"
|
||||
"}\n");
|
||||
}
|
||||
}
|
||||
|
||||
void StringFieldGenerator::
|
||||
GenerateMergingCode(io::Printer* printer) const {
|
||||
printer->Print(variables_, "set_$name$(from.$name$());\n");
|
||||
}
|
||||
|
||||
void StringFieldGenerator::
|
||||
GenerateSwappingCode(io::Printer* printer) const {
|
||||
printer->Print(variables_, "std::swap($name$_, other->$name$_);\n");
|
||||
}
|
||||
|
||||
void StringFieldGenerator::
|
||||
GenerateConstructorCode(io::Printer* printer) const {
|
||||
printer->Print(variables_,
|
||||
"$name$_ = const_cast< ::std::string*>(&$default_variable$);\n");
|
||||
}
|
||||
|
||||
void StringFieldGenerator::
|
||||
GenerateDestructorCode(io::Printer* printer) const {
|
||||
printer->Print(variables_,
|
||||
"if ($name$_ != &$default_variable$) {\n"
|
||||
" delete $name$_;\n"
|
||||
"}\n");
|
||||
}
|
||||
|
||||
void StringFieldGenerator::
|
||||
GenerateMergeFromCodedStream(io::Printer* printer) const {
|
||||
printer->Print(variables_,
|
||||
"DO_(::google::protobuf::internal::WireFormatLite::Read$declared_type$(\n"
|
||||
" input, this->mutable_$name$()));\n");
|
||||
if (HasUtf8Verification(descriptor_->file()) &&
|
||||
descriptor_->type() == FieldDescriptor::TYPE_STRING) {
|
||||
printer->Print(variables_,
|
||||
"::google::protobuf::internal::WireFormat::VerifyUTF8String(\n"
|
||||
" this->$name$().data(), this->$name$().length(),\n"
|
||||
" ::google::protobuf::internal::WireFormat::PARSE);\n");
|
||||
}
|
||||
}
|
||||
|
||||
void StringFieldGenerator::
|
||||
GenerateSerializeWithCachedSizes(io::Printer* printer) const {
|
||||
if (HasUtf8Verification(descriptor_->file()) &&
|
||||
descriptor_->type() == FieldDescriptor::TYPE_STRING) {
|
||||
printer->Print(variables_,
|
||||
"::google::protobuf::internal::WireFormat::VerifyUTF8String(\n"
|
||||
" this->$name$().data(), this->$name$().length(),\n"
|
||||
" ::google::protobuf::internal::WireFormat::SERIALIZE);\n");
|
||||
}
|
||||
printer->Print(variables_,
|
||||
"::google::protobuf::internal::WireFormatLite::Write$declared_type$(\n"
|
||||
" $number$, this->$name$(), output);\n");
|
||||
}
|
||||
|
||||
void StringFieldGenerator::
|
||||
GenerateSerializeWithCachedSizesToArray(io::Printer* printer) const {
|
||||
if (HasUtf8Verification(descriptor_->file()) &&
|
||||
descriptor_->type() == FieldDescriptor::TYPE_STRING) {
|
||||
printer->Print(variables_,
|
||||
"::google::protobuf::internal::WireFormat::VerifyUTF8String(\n"
|
||||
" this->$name$().data(), this->$name$().length(),\n"
|
||||
" ::google::protobuf::internal::WireFormat::SERIALIZE);\n");
|
||||
}
|
||||
printer->Print(variables_,
|
||||
"target =\n"
|
||||
" ::google::protobuf::internal::WireFormatLite::Write$declared_type$ToArray(\n"
|
||||
" $number$, this->$name$(), target);\n");
|
||||
}
|
||||
|
||||
void StringFieldGenerator::
|
||||
GenerateByteSize(io::Printer* printer) const {
|
||||
printer->Print(variables_,
|
||||
"total_size += $tag_size$ +\n"
|
||||
" ::google::protobuf::internal::WireFormatLite::$declared_type$Size(\n"
|
||||
" this->$name$());\n");
|
||||
}
|
||||
|
||||
// ===================================================================
|
||||
|
||||
RepeatedStringFieldGenerator::
|
||||
RepeatedStringFieldGenerator(const FieldDescriptor* descriptor)
|
||||
: descriptor_(descriptor) {
|
||||
SetStringVariables(descriptor, &variables_);
|
||||
}
|
||||
|
||||
RepeatedStringFieldGenerator::~RepeatedStringFieldGenerator() {}
|
||||
|
||||
void RepeatedStringFieldGenerator::
|
||||
GeneratePrivateMembers(io::Printer* printer) const {
|
||||
printer->Print(variables_,
|
||||
"::google::protobuf::RepeatedPtrField< ::std::string> $name$_;\n");
|
||||
}
|
||||
|
||||
void RepeatedStringFieldGenerator::
|
||||
GenerateAccessorDeclarations(io::Printer* printer) const {
|
||||
// See comment above about unknown ctypes.
|
||||
if (descriptor_->options().ctype() != FieldOptions::STRING) {
|
||||
printer->Outdent();
|
||||
printer->Print(
|
||||
" private:\n"
|
||||
" // Hidden due to unknown ctype option.\n");
|
||||
printer->Indent();
|
||||
}
|
||||
|
||||
printer->Print(variables_,
|
||||
"inline const ::std::string& $name$(int index) const$deprecation$;\n"
|
||||
"inline ::std::string* mutable_$name$(int index)$deprecation$;\n"
|
||||
"inline void set_$name$(int index, const ::std::string& value)$deprecation$;\n"
|
||||
"inline void set_$name$(int index, const char* value)$deprecation$;\n"
|
||||
"inline "
|
||||
"void set_$name$(int index, const $pointer_type$* value, size_t size)"
|
||||
"$deprecation$;\n"
|
||||
"inline ::std::string* add_$name$()$deprecation$;\n"
|
||||
"inline void add_$name$(const ::std::string& value)$deprecation$;\n"
|
||||
"inline void add_$name$(const char* value)$deprecation$;\n"
|
||||
"inline void add_$name$(const $pointer_type$* value, size_t size)"
|
||||
"$deprecation$;\n");
|
||||
|
||||
printer->Print(variables_,
|
||||
"inline const ::google::protobuf::RepeatedPtrField< ::std::string>& $name$() const"
|
||||
"$deprecation$;\n"
|
||||
"inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_$name$()"
|
||||
"$deprecation$;\n");
|
||||
|
||||
if (descriptor_->options().ctype() != FieldOptions::STRING) {
|
||||
printer->Outdent();
|
||||
printer->Print(" public:\n");
|
||||
printer->Indent();
|
||||
}
|
||||
}
|
||||
|
||||
void RepeatedStringFieldGenerator::
|
||||
GenerateInlineAccessorDefinitions(io::Printer* printer) const {
|
||||
printer->Print(variables_,
|
||||
"inline const ::std::string& $classname$::$name$(int index) const {\n"
|
||||
" return $name$_.Get(index);\n"
|
||||
"}\n"
|
||||
"inline ::std::string* $classname$::mutable_$name$(int index) {\n"
|
||||
" return $name$_.Mutable(index);\n"
|
||||
"}\n"
|
||||
"inline void $classname$::set_$name$(int index, const ::std::string& value) {\n"
|
||||
" $name$_.Mutable(index)->assign(value);\n"
|
||||
"}\n"
|
||||
"inline void $classname$::set_$name$(int index, const char* value) {\n"
|
||||
" $name$_.Mutable(index)->assign(value);\n"
|
||||
"}\n"
|
||||
"inline void "
|
||||
"$classname$::set_$name$"
|
||||
"(int index, const $pointer_type$* value, size_t size) {\n"
|
||||
" $name$_.Mutable(index)->assign(\n"
|
||||
" reinterpret_cast<const char*>(value), size);\n"
|
||||
"}\n"
|
||||
"inline ::std::string* $classname$::add_$name$() {\n"
|
||||
" return $name$_.Add();\n"
|
||||
"}\n"
|
||||
"inline void $classname$::add_$name$(const ::std::string& value) {\n"
|
||||
" $name$_.Add()->assign(value);\n"
|
||||
"}\n"
|
||||
"inline void $classname$::add_$name$(const char* value) {\n"
|
||||
" $name$_.Add()->assign(value);\n"
|
||||
"}\n"
|
||||
"inline void "
|
||||
"$classname$::add_$name$(const $pointer_type$* value, size_t size) {\n"
|
||||
" $name$_.Add()->assign(reinterpret_cast<const char*>(value), size);\n"
|
||||
"}\n");
|
||||
printer->Print(variables_,
|
||||
"inline const ::google::protobuf::RepeatedPtrField< ::std::string>&\n"
|
||||
"$classname$::$name$() const {\n"
|
||||
" return $name$_;\n"
|
||||
"}\n"
|
||||
"inline ::google::protobuf::RepeatedPtrField< ::std::string>*\n"
|
||||
"$classname$::mutable_$name$() {\n"
|
||||
" return &$name$_;\n"
|
||||
"}\n");
|
||||
}
|
||||
|
||||
void RepeatedStringFieldGenerator::
|
||||
GenerateClearingCode(io::Printer* printer) const {
|
||||
printer->Print(variables_, "$name$_.Clear();\n");
|
||||
}
|
||||
|
||||
void RepeatedStringFieldGenerator::
|
||||
GenerateMergingCode(io::Printer* printer) const {
|
||||
printer->Print(variables_, "$name$_.MergeFrom(from.$name$_);\n");
|
||||
}
|
||||
|
||||
void RepeatedStringFieldGenerator::
|
||||
GenerateSwappingCode(io::Printer* printer) const {
|
||||
printer->Print(variables_, "$name$_.Swap(&other->$name$_);\n");
|
||||
}
|
||||
|
||||
void RepeatedStringFieldGenerator::
|
||||
GenerateConstructorCode(io::Printer* printer) const {
|
||||
// Not needed for repeated fields.
|
||||
}
|
||||
|
||||
void RepeatedStringFieldGenerator::
|
||||
GenerateMergeFromCodedStream(io::Printer* printer) const {
|
||||
printer->Print(variables_,
|
||||
"DO_(::google::protobuf::internal::WireFormatLite::Read$declared_type$(\n"
|
||||
" input, this->add_$name$()));\n");
|
||||
if (HasUtf8Verification(descriptor_->file()) &&
|
||||
descriptor_->type() == FieldDescriptor::TYPE_STRING) {
|
||||
printer->Print(variables_,
|
||||
"::google::protobuf::internal::WireFormat::VerifyUTF8String(\n"
|
||||
" this->$name$(0).data(), this->$name$(0).length(),\n"
|
||||
" ::google::protobuf::internal::WireFormat::PARSE);\n");
|
||||
}
|
||||
}
|
||||
|
||||
void RepeatedStringFieldGenerator::
|
||||
GenerateSerializeWithCachedSizes(io::Printer* printer) const {
|
||||
printer->Print(variables_,
|
||||
"for (int i = 0; i < this->$name$_size(); i++) {\n");
|
||||
if (HasUtf8Verification(descriptor_->file()) &&
|
||||
descriptor_->type() == FieldDescriptor::TYPE_STRING) {
|
||||
printer->Print(variables_,
|
||||
"::google::protobuf::internal::WireFormat::VerifyUTF8String(\n"
|
||||
" this->$name$(i).data(), this->$name$(i).length(),\n"
|
||||
" ::google::protobuf::internal::WireFormat::SERIALIZE);\n");
|
||||
}
|
||||
printer->Print(variables_,
|
||||
" ::google::protobuf::internal::WireFormatLite::Write$declared_type$(\n"
|
||||
" $number$, this->$name$(i), output);\n"
|
||||
"}\n");
|
||||
}
|
||||
|
||||
void RepeatedStringFieldGenerator::
|
||||
GenerateSerializeWithCachedSizesToArray(io::Printer* printer) const {
|
||||
printer->Print(variables_,
|
||||
"for (int i = 0; i < this->$name$_size(); i++) {\n");
|
||||
if (HasUtf8Verification(descriptor_->file()) &&
|
||||
descriptor_->type() == FieldDescriptor::TYPE_STRING) {
|
||||
printer->Print(variables_,
|
||||
" ::google::protobuf::internal::WireFormat::VerifyUTF8String(\n"
|
||||
" this->$name$(i).data(), this->$name$(i).length(),\n"
|
||||
" ::google::protobuf::internal::WireFormat::SERIALIZE);\n");
|
||||
}
|
||||
printer->Print(variables_,
|
||||
" target = ::google::protobuf::internal::WireFormatLite::\n"
|
||||
" Write$declared_type$ToArray($number$, this->$name$(i), target);\n"
|
||||
"}\n");
|
||||
}
|
||||
|
||||
void RepeatedStringFieldGenerator::
|
||||
GenerateByteSize(io::Printer* printer) const {
|
||||
printer->Print(variables_,
|
||||
"total_size += $tag_size$ * this->$name$_size();\n"
|
||||
"for (int i = 0; i < this->$name$_size(); i++) {\n"
|
||||
" total_size += ::google::protobuf::internal::WireFormatLite::$declared_type$Size(\n"
|
||||
" this->$name$(i));\n"
|
||||
"}\n");
|
||||
}
|
||||
|
||||
} // namespace cpp
|
||||
} // namespace compiler
|
||||
} // namespace protobuf
|
||||
} // namespace google
|
||||
@ -1,104 +0,0 @@
|
||||
// Protocol Buffers - Google's data interchange format
|
||||
// Copyright 2008 Google Inc. All rights reserved.
|
||||
// http://code.google.com/p/protobuf/
|
||||
//
|
||||
// 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.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// 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.
|
||||
|
||||
// Author: kenton@google.com (Kenton Varda)
|
||||
// Based on original Protocol Buffers design by
|
||||
// Sanjay Ghemawat, Jeff Dean, and others.
|
||||
|
||||
#ifndef GOOGLE_PROTOBUF_COMPILER_CPP_STRING_FIELD_H__
|
||||
#define GOOGLE_PROTOBUF_COMPILER_CPP_STRING_FIELD_H__
|
||||
|
||||
#include <map>
|
||||
#include <string>
|
||||
#include <google/protobuf/compiler/cpp/cpp_field.h>
|
||||
|
||||
namespace google {
|
||||
namespace protobuf {
|
||||
namespace compiler {
|
||||
namespace cpp {
|
||||
|
||||
class StringFieldGenerator : public FieldGenerator {
|
||||
public:
|
||||
explicit StringFieldGenerator(const FieldDescriptor* descriptor);
|
||||
~StringFieldGenerator();
|
||||
|
||||
// implements FieldGenerator ---------------------------------------
|
||||
void GeneratePrivateMembers(io::Printer* printer) const;
|
||||
void GenerateAccessorDeclarations(io::Printer* printer) const;
|
||||
void GenerateInlineAccessorDefinitions(io::Printer* printer) const;
|
||||
void GenerateNonInlineAccessorDefinitions(io::Printer* printer) const;
|
||||
void GenerateClearingCode(io::Printer* printer) const;
|
||||
void GenerateMergingCode(io::Printer* printer) const;
|
||||
void GenerateSwappingCode(io::Printer* printer) const;
|
||||
void GenerateConstructorCode(io::Printer* printer) const;
|
||||
void GenerateDestructorCode(io::Printer* printer) const;
|
||||
void GenerateMergeFromCodedStream(io::Printer* printer) const;
|
||||
void GenerateSerializeWithCachedSizes(io::Printer* printer) const;
|
||||
void GenerateSerializeWithCachedSizesToArray(io::Printer* printer) const;
|
||||
void GenerateByteSize(io::Printer* printer) const;
|
||||
|
||||
private:
|
||||
const FieldDescriptor* descriptor_;
|
||||
map<string, string> variables_;
|
||||
|
||||
GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(StringFieldGenerator);
|
||||
};
|
||||
|
||||
class RepeatedStringFieldGenerator : public FieldGenerator {
|
||||
public:
|
||||
explicit RepeatedStringFieldGenerator(const FieldDescriptor* descriptor);
|
||||
~RepeatedStringFieldGenerator();
|
||||
|
||||
// implements FieldGenerator ---------------------------------------
|
||||
void GeneratePrivateMembers(io::Printer* printer) const;
|
||||
void GenerateAccessorDeclarations(io::Printer* printer) const;
|
||||
void GenerateInlineAccessorDefinitions(io::Printer* printer) const;
|
||||
void GenerateClearingCode(io::Printer* printer) const;
|
||||
void GenerateMergingCode(io::Printer* printer) const;
|
||||
void GenerateSwappingCode(io::Printer* printer) const;
|
||||
void GenerateConstructorCode(io::Printer* printer) const;
|
||||
void GenerateMergeFromCodedStream(io::Printer* printer) const;
|
||||
void GenerateSerializeWithCachedSizes(io::Printer* printer) const;
|
||||
void GenerateSerializeWithCachedSizesToArray(io::Printer* printer) const;
|
||||
void GenerateByteSize(io::Printer* printer) const;
|
||||
|
||||
private:
|
||||
const FieldDescriptor* descriptor_;
|
||||
map<string, string> variables_;
|
||||
|
||||
GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(RepeatedStringFieldGenerator);
|
||||
};
|
||||
|
||||
} // namespace cpp
|
||||
} // namespace compiler
|
||||
} // namespace protobuf
|
||||
|
||||
} // namespace google
|
||||
#endif // GOOGLE_PROTOBUF_COMPILER_CPP_STRING_FIELD_H__
|
||||
File diff suppressed because it is too large
Load Diff
@ -1,231 +0,0 @@
|
||||
// Protocol Buffers - Google's data interchange format
|
||||
// Copyright 2008 Google Inc. All rights reserved.
|
||||
// http://code.google.com/p/protobuf/
|
||||
//
|
||||
// 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.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// 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.
|
||||
|
||||
// Author: kenton@google.com (Kenton Varda)
|
||||
|
||||
#include <google/protobuf/compiler/mock_code_generator.h>
|
||||
|
||||
#include <google/protobuf/testing/file.h>
|
||||
#include <google/protobuf/descriptor.h>
|
||||
#include <google/protobuf/io/zero_copy_stream.h>
|
||||
#include <google/protobuf/io/printer.h>
|
||||
#include <google/protobuf/stubs/strutil.h>
|
||||
#include <google/protobuf/stubs/substitute.h>
|
||||
#include <gtest/gtest.h>
|
||||
#include <google/protobuf/stubs/stl_util-inl.h>
|
||||
|
||||
namespace google {
|
||||
namespace protobuf {
|
||||
namespace compiler {
|
||||
|
||||
// Returns the list of the names of files in all_files in the form of a
|
||||
// comma-separated string.
|
||||
string CommaSeparatedList(const vector<const FileDescriptor*> all_files) {
|
||||
vector<string> names;
|
||||
for (int i = 0; i < all_files.size(); i++) {
|
||||
names.push_back(all_files[i]->name());
|
||||
}
|
||||
return JoinStrings(names, ",");
|
||||
}
|
||||
|
||||
static const char* kFirstInsertionPointName = "first_mock_insertion_point";
|
||||
static const char* kSecondInsertionPointName = "second_mock_insertion_point";
|
||||
static const char* kFirstInsertionPoint =
|
||||
"# @@protoc_insertion_point(first_mock_insertion_point) is here\n";
|
||||
static const char* kSecondInsertionPoint =
|
||||
" # @@protoc_insertion_point(second_mock_insertion_point) is here\n";
|
||||
|
||||
MockCodeGenerator::MockCodeGenerator(const string& name)
|
||||
: name_(name) {}
|
||||
|
||||
MockCodeGenerator::~MockCodeGenerator() {}
|
||||
|
||||
void MockCodeGenerator::ExpectGenerated(
|
||||
const string& name,
|
||||
const string& parameter,
|
||||
const string& insertions,
|
||||
const string& file,
|
||||
const string& first_message_name,
|
||||
const string& first_parsed_file_name,
|
||||
const string& output_directory) {
|
||||
string content;
|
||||
ASSERT_TRUE(File::ReadFileToString(
|
||||
output_directory + "/" + GetOutputFileName(name, file), &content));
|
||||
|
||||
vector<string> lines;
|
||||
SplitStringUsing(content, "\n", &lines);
|
||||
|
||||
while (!lines.empty() && lines.back().empty()) {
|
||||
lines.pop_back();
|
||||
}
|
||||
for (int i = 0; i < lines.size(); i++) {
|
||||
lines[i] += "\n";
|
||||
}
|
||||
|
||||
vector<string> insertion_list;
|
||||
if (!insertions.empty()) {
|
||||
SplitStringUsing(insertions, ",", &insertion_list);
|
||||
}
|
||||
|
||||
ASSERT_EQ(lines.size(), 3 + insertion_list.size() * 2);
|
||||
EXPECT_EQ(GetOutputFileContent(name, parameter, file,
|
||||
first_parsed_file_name, first_message_name),
|
||||
lines[0]);
|
||||
|
||||
EXPECT_EQ(kFirstInsertionPoint, lines[1 + insertion_list.size()]);
|
||||
EXPECT_EQ(kSecondInsertionPoint, lines[2 + insertion_list.size() * 2]);
|
||||
|
||||
for (int i = 0; i < insertion_list.size(); i++) {
|
||||
EXPECT_EQ(GetOutputFileContent(insertion_list[i], "first_insert",
|
||||
file, file, first_message_name),
|
||||
lines[1 + i]);
|
||||
// Second insertion point is indented, so the inserted text should
|
||||
// automatically be indented too.
|
||||
EXPECT_EQ(" " + GetOutputFileContent(insertion_list[i], "second_insert",
|
||||
file, file, first_message_name),
|
||||
lines[2 + insertion_list.size() + i]);
|
||||
}
|
||||
}
|
||||
|
||||
bool MockCodeGenerator::Generate(
|
||||
const FileDescriptor* file,
|
||||
const string& parameter,
|
||||
GeneratorContext* context,
|
||||
string* error) const {
|
||||
for (int i = 0; i < file->message_type_count(); i++) {
|
||||
if (HasPrefixString(file->message_type(i)->name(), "MockCodeGenerator_")) {
|
||||
string command = StripPrefixString(file->message_type(i)->name(),
|
||||
"MockCodeGenerator_");
|
||||
if (command == "Error") {
|
||||
*error = "Saw message type MockCodeGenerator_Error.";
|
||||
return false;
|
||||
} else if (command == "Exit") {
|
||||
cerr << "Saw message type MockCodeGenerator_Exit." << endl;
|
||||
exit(123);
|
||||
} else if (command == "Abort") {
|
||||
cerr << "Saw message type MockCodeGenerator_Abort." << endl;
|
||||
abort();
|
||||
} else {
|
||||
GOOGLE_LOG(FATAL) << "Unknown MockCodeGenerator command: " << command;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (HasPrefixString(parameter, "insert=")) {
|
||||
vector<string> insert_into;
|
||||
SplitStringUsing(StripPrefixString(parameter, "insert="),
|
||||
",", &insert_into);
|
||||
|
||||
for (int i = 0; i < insert_into.size(); i++) {
|
||||
{
|
||||
scoped_ptr<io::ZeroCopyOutputStream> output(
|
||||
context->OpenForInsert(
|
||||
GetOutputFileName(insert_into[i], file),
|
||||
kFirstInsertionPointName));
|
||||
io::Printer printer(output.get(), '$');
|
||||
printer.PrintRaw(GetOutputFileContent(name_, "first_insert",
|
||||
file, context));
|
||||
if (printer.failed()) {
|
||||
*error = "MockCodeGenerator detected write error.";
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
{
|
||||
scoped_ptr<io::ZeroCopyOutputStream> output(
|
||||
context->OpenForInsert(
|
||||
GetOutputFileName(insert_into[i], file),
|
||||
kSecondInsertionPointName));
|
||||
io::Printer printer(output.get(), '$');
|
||||
printer.PrintRaw(GetOutputFileContent(name_, "second_insert",
|
||||
file, context));
|
||||
if (printer.failed()) {
|
||||
*error = "MockCodeGenerator detected write error.";
|
||||
return false;
|
||||
}
|
||||
}
|
||||
}
|
||||
} else {
|
||||
scoped_ptr<io::ZeroCopyOutputStream> output(
|
||||
context->Open(GetOutputFileName(name_, file)));
|
||||
|
||||
io::Printer printer(output.get(), '$');
|
||||
printer.PrintRaw(GetOutputFileContent(name_, parameter,
|
||||
file, context));
|
||||
printer.PrintRaw(kFirstInsertionPoint);
|
||||
printer.PrintRaw(kSecondInsertionPoint);
|
||||
|
||||
if (printer.failed()) {
|
||||
*error = "MockCodeGenerator detected write error.";
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
string MockCodeGenerator::GetOutputFileName(const string& generator_name,
|
||||
const FileDescriptor* file) {
|
||||
return GetOutputFileName(generator_name, file->name());
|
||||
}
|
||||
|
||||
string MockCodeGenerator::GetOutputFileName(const string& generator_name,
|
||||
const string& file) {
|
||||
return file + ".MockCodeGenerator." + generator_name;
|
||||
}
|
||||
|
||||
string MockCodeGenerator::GetOutputFileContent(
|
||||
const string& generator_name,
|
||||
const string& parameter,
|
||||
const FileDescriptor* file,
|
||||
GeneratorContext *context) {
|
||||
vector<const FileDescriptor*> all_files;
|
||||
context->ListParsedFiles(&all_files);
|
||||
return GetOutputFileContent(
|
||||
generator_name, parameter, file->name(),
|
||||
CommaSeparatedList(all_files),
|
||||
file->message_type_count() > 0 ?
|
||||
file->message_type(0)->name() : "(none)");
|
||||
}
|
||||
|
||||
string MockCodeGenerator::GetOutputFileContent(
|
||||
const string& generator_name,
|
||||
const string& parameter,
|
||||
const string& file,
|
||||
const string& parsed_file_list,
|
||||
const string& first_message_name) {
|
||||
return strings::Substitute("$0: $1, $2, $3, $4\n",
|
||||
generator_name, parameter, file,
|
||||
first_message_name, parsed_file_list);
|
||||
}
|
||||
|
||||
} // namespace compiler
|
||||
} // namespace protobuf
|
||||
} // namespace google
|
||||
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
@ -1,790 +0,0 @@
|
||||
// Generated by the protocol buffer compiler. DO NOT EDIT!
|
||||
// source: google/protobuf/compiler/plugin.proto
|
||||
|
||||
#ifndef PROTOBUF_google_2fprotobuf_2fcompiler_2fplugin_2eproto__INCLUDED
|
||||
#define PROTOBUF_google_2fprotobuf_2fcompiler_2fplugin_2eproto__INCLUDED
|
||||
|
||||
#include <string>
|
||||
|
||||
#include <google/protobuf/stubs/common.h>
|
||||
|
||||
#if GOOGLE_PROTOBUF_VERSION < 2004000
|
||||
#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 2004001 < 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/generated_message_util.h>
|
||||
#include <google/protobuf/repeated_field.h>
|
||||
#include <google/protobuf/extension_set.h>
|
||||
#include <google/protobuf/generated_message_reflection.h>
|
||||
#include "google/protobuf/descriptor.pb.h"
|
||||
// @@protoc_insertion_point(includes)
|
||||
|
||||
namespace google {
|
||||
namespace protobuf {
|
||||
namespace compiler {
|
||||
|
||||
// Internal implementation detail -- do not call these.
|
||||
void LIBPROTOC_EXPORT protobuf_AddDesc_google_2fprotobuf_2fcompiler_2fplugin_2eproto();
|
||||
void protobuf_AssignDesc_google_2fprotobuf_2fcompiler_2fplugin_2eproto();
|
||||
void protobuf_ShutdownFile_google_2fprotobuf_2fcompiler_2fplugin_2eproto();
|
||||
|
||||
class CodeGeneratorRequest;
|
||||
class CodeGeneratorResponse;
|
||||
class CodeGeneratorResponse_File;
|
||||
|
||||
// ===================================================================
|
||||
|
||||
class LIBPROTOC_EXPORT CodeGeneratorRequest : public ::google::protobuf::Message {
|
||||
public:
|
||||
CodeGeneratorRequest();
|
||||
virtual ~CodeGeneratorRequest();
|
||||
|
||||
CodeGeneratorRequest(const CodeGeneratorRequest& from);
|
||||
|
||||
inline CodeGeneratorRequest& operator=(const CodeGeneratorRequest& from) {
|
||||
CopyFrom(from);
|
||||
return *this;
|
||||
}
|
||||
|
||||
inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
|
||||
return _unknown_fields_;
|
||||
}
|
||||
|
||||
inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
|
||||
return &_unknown_fields_;
|
||||
}
|
||||
|
||||
static const ::google::protobuf::Descriptor* descriptor();
|
||||
static const CodeGeneratorRequest& default_instance();
|
||||
|
||||
void Swap(CodeGeneratorRequest* other);
|
||||
|
||||
// implements Message ----------------------------------------------
|
||||
|
||||
CodeGeneratorRequest* New() const;
|
||||
void CopyFrom(const ::google::protobuf::Message& from);
|
||||
void MergeFrom(const ::google::protobuf::Message& from);
|
||||
void CopyFrom(const CodeGeneratorRequest& from);
|
||||
void MergeFrom(const CodeGeneratorRequest& from);
|
||||
void Clear();
|
||||
bool IsInitialized() const;
|
||||
|
||||
int ByteSize() const;
|
||||
bool MergePartialFromCodedStream(
|
||||
::google::protobuf::io::CodedInputStream* input);
|
||||
void SerializeWithCachedSizes(
|
||||
::google::protobuf::io::CodedOutputStream* output) const;
|
||||
::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
|
||||
int GetCachedSize() const { return _cached_size_; }
|
||||
private:
|
||||
void SharedCtor();
|
||||
void SharedDtor();
|
||||
void SetCachedSize(int size) const;
|
||||
public:
|
||||
|
||||
::google::protobuf::Metadata GetMetadata() const;
|
||||
|
||||
// nested types ----------------------------------------------------
|
||||
|
||||
// accessors -------------------------------------------------------
|
||||
|
||||
// repeated string file_to_generate = 1;
|
||||
inline int file_to_generate_size() const;
|
||||
inline void clear_file_to_generate();
|
||||
static const int kFileToGenerateFieldNumber = 1;
|
||||
inline const ::std::string& file_to_generate(int index) const;
|
||||
inline ::std::string* mutable_file_to_generate(int index);
|
||||
inline void set_file_to_generate(int index, const ::std::string& value);
|
||||
inline void set_file_to_generate(int index, const char* value);
|
||||
inline void set_file_to_generate(int index, const char* value, size_t size);
|
||||
inline ::std::string* add_file_to_generate();
|
||||
inline void add_file_to_generate(const ::std::string& value);
|
||||
inline void add_file_to_generate(const char* value);
|
||||
inline void add_file_to_generate(const char* value, size_t size);
|
||||
inline const ::google::protobuf::RepeatedPtrField< ::std::string>& file_to_generate() const;
|
||||
inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_file_to_generate();
|
||||
|
||||
// optional string parameter = 2;
|
||||
inline bool has_parameter() const;
|
||||
inline void clear_parameter();
|
||||
static const int kParameterFieldNumber = 2;
|
||||
inline const ::std::string& parameter() const;
|
||||
inline void set_parameter(const ::std::string& value);
|
||||
inline void set_parameter(const char* value);
|
||||
inline void set_parameter(const char* value, size_t size);
|
||||
inline ::std::string* mutable_parameter();
|
||||
inline ::std::string* release_parameter();
|
||||
|
||||
// repeated .google.protobuf.FileDescriptorProto proto_file = 15;
|
||||
inline int proto_file_size() const;
|
||||
inline void clear_proto_file();
|
||||
static const int kProtoFileFieldNumber = 15;
|
||||
inline const ::google::protobuf::FileDescriptorProto& proto_file(int index) const;
|
||||
inline ::google::protobuf::FileDescriptorProto* mutable_proto_file(int index);
|
||||
inline ::google::protobuf::FileDescriptorProto* add_proto_file();
|
||||
inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::FileDescriptorProto >&
|
||||
proto_file() const;
|
||||
inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::FileDescriptorProto >*
|
||||
mutable_proto_file();
|
||||
|
||||
// @@protoc_insertion_point(class_scope:google.protobuf.compiler.CodeGeneratorRequest)
|
||||
private:
|
||||
inline void set_has_parameter();
|
||||
inline void clear_has_parameter();
|
||||
|
||||
::google::protobuf::UnknownFieldSet _unknown_fields_;
|
||||
|
||||
::google::protobuf::RepeatedPtrField< ::std::string> file_to_generate_;
|
||||
::std::string* parameter_;
|
||||
::google::protobuf::RepeatedPtrField< ::google::protobuf::FileDescriptorProto > proto_file_;
|
||||
|
||||
mutable int _cached_size_;
|
||||
::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];
|
||||
|
||||
friend void LIBPROTOC_EXPORT protobuf_AddDesc_google_2fprotobuf_2fcompiler_2fplugin_2eproto();
|
||||
friend void protobuf_AssignDesc_google_2fprotobuf_2fcompiler_2fplugin_2eproto();
|
||||
friend void protobuf_ShutdownFile_google_2fprotobuf_2fcompiler_2fplugin_2eproto();
|
||||
|
||||
void InitAsDefaultInstance();
|
||||
static CodeGeneratorRequest* default_instance_;
|
||||
};
|
||||
// -------------------------------------------------------------------
|
||||
|
||||
class LIBPROTOC_EXPORT CodeGeneratorResponse_File : public ::google::protobuf::Message {
|
||||
public:
|
||||
CodeGeneratorResponse_File();
|
||||
virtual ~CodeGeneratorResponse_File();
|
||||
|
||||
CodeGeneratorResponse_File(const CodeGeneratorResponse_File& from);
|
||||
|
||||
inline CodeGeneratorResponse_File& operator=(const CodeGeneratorResponse_File& from) {
|
||||
CopyFrom(from);
|
||||
return *this;
|
||||
}
|
||||
|
||||
inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
|
||||
return _unknown_fields_;
|
||||
}
|
||||
|
||||
inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
|
||||
return &_unknown_fields_;
|
||||
}
|
||||
|
||||
static const ::google::protobuf::Descriptor* descriptor();
|
||||
static const CodeGeneratorResponse_File& default_instance();
|
||||
|
||||
void Swap(CodeGeneratorResponse_File* other);
|
||||
|
||||
// implements Message ----------------------------------------------
|
||||
|
||||
CodeGeneratorResponse_File* New() const;
|
||||
void CopyFrom(const ::google::protobuf::Message& from);
|
||||
void MergeFrom(const ::google::protobuf::Message& from);
|
||||
void CopyFrom(const CodeGeneratorResponse_File& from);
|
||||
void MergeFrom(const CodeGeneratorResponse_File& from);
|
||||
void Clear();
|
||||
bool IsInitialized() const;
|
||||
|
||||
int ByteSize() const;
|
||||
bool MergePartialFromCodedStream(
|
||||
::google::protobuf::io::CodedInputStream* input);
|
||||
void SerializeWithCachedSizes(
|
||||
::google::protobuf::io::CodedOutputStream* output) const;
|
||||
::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
|
||||
int GetCachedSize() const { return _cached_size_; }
|
||||
private:
|
||||
void SharedCtor();
|
||||
void SharedDtor();
|
||||
void SetCachedSize(int size) const;
|
||||
public:
|
||||
|
||||
::google::protobuf::Metadata GetMetadata() const;
|
||||
|
||||
// nested types ----------------------------------------------------
|
||||
|
||||
// accessors -------------------------------------------------------
|
||||
|
||||
// optional string name = 1;
|
||||
inline bool has_name() const;
|
||||
inline void clear_name();
|
||||
static const int kNameFieldNumber = 1;
|
||||
inline const ::std::string& name() const;
|
||||
inline void set_name(const ::std::string& value);
|
||||
inline void set_name(const char* value);
|
||||
inline void set_name(const char* value, size_t size);
|
||||
inline ::std::string* mutable_name();
|
||||
inline ::std::string* release_name();
|
||||
|
||||
// optional string insertion_point = 2;
|
||||
inline bool has_insertion_point() const;
|
||||
inline void clear_insertion_point();
|
||||
static const int kInsertionPointFieldNumber = 2;
|
||||
inline const ::std::string& insertion_point() const;
|
||||
inline void set_insertion_point(const ::std::string& value);
|
||||
inline void set_insertion_point(const char* value);
|
||||
inline void set_insertion_point(const char* value, size_t size);
|
||||
inline ::std::string* mutable_insertion_point();
|
||||
inline ::std::string* release_insertion_point();
|
||||
|
||||
// optional string content = 15;
|
||||
inline bool has_content() const;
|
||||
inline void clear_content();
|
||||
static const int kContentFieldNumber = 15;
|
||||
inline const ::std::string& content() const;
|
||||
inline void set_content(const ::std::string& value);
|
||||
inline void set_content(const char* value);
|
||||
inline void set_content(const char* value, size_t size);
|
||||
inline ::std::string* mutable_content();
|
||||
inline ::std::string* release_content();
|
||||
|
||||
// @@protoc_insertion_point(class_scope:google.protobuf.compiler.CodeGeneratorResponse.File)
|
||||
private:
|
||||
inline void set_has_name();
|
||||
inline void clear_has_name();
|
||||
inline void set_has_insertion_point();
|
||||
inline void clear_has_insertion_point();
|
||||
inline void set_has_content();
|
||||
inline void clear_has_content();
|
||||
|
||||
::google::protobuf::UnknownFieldSet _unknown_fields_;
|
||||
|
||||
::std::string* name_;
|
||||
::std::string* insertion_point_;
|
||||
::std::string* content_;
|
||||
|
||||
mutable int _cached_size_;
|
||||
::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];
|
||||
|
||||
friend void LIBPROTOC_EXPORT protobuf_AddDesc_google_2fprotobuf_2fcompiler_2fplugin_2eproto();
|
||||
friend void protobuf_AssignDesc_google_2fprotobuf_2fcompiler_2fplugin_2eproto();
|
||||
friend void protobuf_ShutdownFile_google_2fprotobuf_2fcompiler_2fplugin_2eproto();
|
||||
|
||||
void InitAsDefaultInstance();
|
||||
static CodeGeneratorResponse_File* default_instance_;
|
||||
};
|
||||
// -------------------------------------------------------------------
|
||||
|
||||
class LIBPROTOC_EXPORT CodeGeneratorResponse : public ::google::protobuf::Message {
|
||||
public:
|
||||
CodeGeneratorResponse();
|
||||
virtual ~CodeGeneratorResponse();
|
||||
|
||||
CodeGeneratorResponse(const CodeGeneratorResponse& from);
|
||||
|
||||
inline CodeGeneratorResponse& operator=(const CodeGeneratorResponse& from) {
|
||||
CopyFrom(from);
|
||||
return *this;
|
||||
}
|
||||
|
||||
inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
|
||||
return _unknown_fields_;
|
||||
}
|
||||
|
||||
inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
|
||||
return &_unknown_fields_;
|
||||
}
|
||||
|
||||
static const ::google::protobuf::Descriptor* descriptor();
|
||||
static const CodeGeneratorResponse& default_instance();
|
||||
|
||||
void Swap(CodeGeneratorResponse* other);
|
||||
|
||||
// implements Message ----------------------------------------------
|
||||
|
||||
CodeGeneratorResponse* New() const;
|
||||
void CopyFrom(const ::google::protobuf::Message& from);
|
||||
void MergeFrom(const ::google::protobuf::Message& from);
|
||||
void CopyFrom(const CodeGeneratorResponse& from);
|
||||
void MergeFrom(const CodeGeneratorResponse& from);
|
||||
void Clear();
|
||||
bool IsInitialized() const;
|
||||
|
||||
int ByteSize() const;
|
||||
bool MergePartialFromCodedStream(
|
||||
::google::protobuf::io::CodedInputStream* input);
|
||||
void SerializeWithCachedSizes(
|
||||
::google::protobuf::io::CodedOutputStream* output) const;
|
||||
::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
|
||||
int GetCachedSize() const { return _cached_size_; }
|
||||
private:
|
||||
void SharedCtor();
|
||||
void SharedDtor();
|
||||
void SetCachedSize(int size) const;
|
||||
public:
|
||||
|
||||
::google::protobuf::Metadata GetMetadata() const;
|
||||
|
||||
// nested types ----------------------------------------------------
|
||||
|
||||
typedef CodeGeneratorResponse_File File;
|
||||
|
||||
// accessors -------------------------------------------------------
|
||||
|
||||
// optional string error = 1;
|
||||
inline bool has_error() const;
|
||||
inline void clear_error();
|
||||
static const int kErrorFieldNumber = 1;
|
||||
inline const ::std::string& error() const;
|
||||
inline void set_error(const ::std::string& value);
|
||||
inline void set_error(const char* value);
|
||||
inline void set_error(const char* value, size_t size);
|
||||
inline ::std::string* mutable_error();
|
||||
inline ::std::string* release_error();
|
||||
|
||||
// repeated .google.protobuf.compiler.CodeGeneratorResponse.File file = 15;
|
||||
inline int file_size() const;
|
||||
inline void clear_file();
|
||||
static const int kFileFieldNumber = 15;
|
||||
inline const ::google::protobuf::compiler::CodeGeneratorResponse_File& file(int index) const;
|
||||
inline ::google::protobuf::compiler::CodeGeneratorResponse_File* mutable_file(int index);
|
||||
inline ::google::protobuf::compiler::CodeGeneratorResponse_File* add_file();
|
||||
inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::compiler::CodeGeneratorResponse_File >&
|
||||
file() const;
|
||||
inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::compiler::CodeGeneratorResponse_File >*
|
||||
mutable_file();
|
||||
|
||||
// @@protoc_insertion_point(class_scope:google.protobuf.compiler.CodeGeneratorResponse)
|
||||
private:
|
||||
inline void set_has_error();
|
||||
inline void clear_has_error();
|
||||
|
||||
::google::protobuf::UnknownFieldSet _unknown_fields_;
|
||||
|
||||
::std::string* error_;
|
||||
::google::protobuf::RepeatedPtrField< ::google::protobuf::compiler::CodeGeneratorResponse_File > file_;
|
||||
|
||||
mutable int _cached_size_;
|
||||
::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];
|
||||
|
||||
friend void LIBPROTOC_EXPORT protobuf_AddDesc_google_2fprotobuf_2fcompiler_2fplugin_2eproto();
|
||||
friend void protobuf_AssignDesc_google_2fprotobuf_2fcompiler_2fplugin_2eproto();
|
||||
friend void protobuf_ShutdownFile_google_2fprotobuf_2fcompiler_2fplugin_2eproto();
|
||||
|
||||
void InitAsDefaultInstance();
|
||||
static CodeGeneratorResponse* default_instance_;
|
||||
};
|
||||
// ===================================================================
|
||||
|
||||
|
||||
// ===================================================================
|
||||
|
||||
// CodeGeneratorRequest
|
||||
|
||||
// repeated string file_to_generate = 1;
|
||||
inline int CodeGeneratorRequest::file_to_generate_size() const {
|
||||
return file_to_generate_.size();
|
||||
}
|
||||
inline void CodeGeneratorRequest::clear_file_to_generate() {
|
||||
file_to_generate_.Clear();
|
||||
}
|
||||
inline const ::std::string& CodeGeneratorRequest::file_to_generate(int index) const {
|
||||
return file_to_generate_.Get(index);
|
||||
}
|
||||
inline ::std::string* CodeGeneratorRequest::mutable_file_to_generate(int index) {
|
||||
return file_to_generate_.Mutable(index);
|
||||
}
|
||||
inline void CodeGeneratorRequest::set_file_to_generate(int index, const ::std::string& value) {
|
||||
file_to_generate_.Mutable(index)->assign(value);
|
||||
}
|
||||
inline void CodeGeneratorRequest::set_file_to_generate(int index, const char* value) {
|
||||
file_to_generate_.Mutable(index)->assign(value);
|
||||
}
|
||||
inline void CodeGeneratorRequest::set_file_to_generate(int index, const char* value, size_t size) {
|
||||
file_to_generate_.Mutable(index)->assign(
|
||||
reinterpret_cast<const char*>(value), size);
|
||||
}
|
||||
inline ::std::string* CodeGeneratorRequest::add_file_to_generate() {
|
||||
return file_to_generate_.Add();
|
||||
}
|
||||
inline void CodeGeneratorRequest::add_file_to_generate(const ::std::string& value) {
|
||||
file_to_generate_.Add()->assign(value);
|
||||
}
|
||||
inline void CodeGeneratorRequest::add_file_to_generate(const char* value) {
|
||||
file_to_generate_.Add()->assign(value);
|
||||
}
|
||||
inline void CodeGeneratorRequest::add_file_to_generate(const char* value, size_t size) {
|
||||
file_to_generate_.Add()->assign(reinterpret_cast<const char*>(value), size);
|
||||
}
|
||||
inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
|
||||
CodeGeneratorRequest::file_to_generate() const {
|
||||
return file_to_generate_;
|
||||
}
|
||||
inline ::google::protobuf::RepeatedPtrField< ::std::string>*
|
||||
CodeGeneratorRequest::mutable_file_to_generate() {
|
||||
return &file_to_generate_;
|
||||
}
|
||||
|
||||
// optional string parameter = 2;
|
||||
inline bool CodeGeneratorRequest::has_parameter() const {
|
||||
return (_has_bits_[0] & 0x00000002u) != 0;
|
||||
}
|
||||
inline void CodeGeneratorRequest::set_has_parameter() {
|
||||
_has_bits_[0] |= 0x00000002u;
|
||||
}
|
||||
inline void CodeGeneratorRequest::clear_has_parameter() {
|
||||
_has_bits_[0] &= ~0x00000002u;
|
||||
}
|
||||
inline void CodeGeneratorRequest::clear_parameter() {
|
||||
if (parameter_ != &::google::protobuf::internal::kEmptyString) {
|
||||
parameter_->clear();
|
||||
}
|
||||
clear_has_parameter();
|
||||
}
|
||||
inline const ::std::string& CodeGeneratorRequest::parameter() const {
|
||||
return *parameter_;
|
||||
}
|
||||
inline void CodeGeneratorRequest::set_parameter(const ::std::string& value) {
|
||||
set_has_parameter();
|
||||
if (parameter_ == &::google::protobuf::internal::kEmptyString) {
|
||||
parameter_ = new ::std::string;
|
||||
}
|
||||
parameter_->assign(value);
|
||||
}
|
||||
inline void CodeGeneratorRequest::set_parameter(const char* value) {
|
||||
set_has_parameter();
|
||||
if (parameter_ == &::google::protobuf::internal::kEmptyString) {
|
||||
parameter_ = new ::std::string;
|
||||
}
|
||||
parameter_->assign(value);
|
||||
}
|
||||
inline void CodeGeneratorRequest::set_parameter(const char* value, size_t size) {
|
||||
set_has_parameter();
|
||||
if (parameter_ == &::google::protobuf::internal::kEmptyString) {
|
||||
parameter_ = new ::std::string;
|
||||
}
|
||||
parameter_->assign(reinterpret_cast<const char*>(value), size);
|
||||
}
|
||||
inline ::std::string* CodeGeneratorRequest::mutable_parameter() {
|
||||
set_has_parameter();
|
||||
if (parameter_ == &::google::protobuf::internal::kEmptyString) {
|
||||
parameter_ = new ::std::string;
|
||||
}
|
||||
return parameter_;
|
||||
}
|
||||
inline ::std::string* CodeGeneratorRequest::release_parameter() {
|
||||
clear_has_parameter();
|
||||
if (parameter_ == &::google::protobuf::internal::kEmptyString) {
|
||||
return NULL;
|
||||
} else {
|
||||
::std::string* temp = parameter_;
|
||||
parameter_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
|
||||
return temp;
|
||||
}
|
||||
}
|
||||
|
||||
// repeated .google.protobuf.FileDescriptorProto proto_file = 15;
|
||||
inline int CodeGeneratorRequest::proto_file_size() const {
|
||||
return proto_file_.size();
|
||||
}
|
||||
inline void CodeGeneratorRequest::clear_proto_file() {
|
||||
proto_file_.Clear();
|
||||
}
|
||||
inline const ::google::protobuf::FileDescriptorProto& CodeGeneratorRequest::proto_file(int index) const {
|
||||
return proto_file_.Get(index);
|
||||
}
|
||||
inline ::google::protobuf::FileDescriptorProto* CodeGeneratorRequest::mutable_proto_file(int index) {
|
||||
return proto_file_.Mutable(index);
|
||||
}
|
||||
inline ::google::protobuf::FileDescriptorProto* CodeGeneratorRequest::add_proto_file() {
|
||||
return proto_file_.Add();
|
||||
}
|
||||
inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::FileDescriptorProto >&
|
||||
CodeGeneratorRequest::proto_file() const {
|
||||
return proto_file_;
|
||||
}
|
||||
inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::FileDescriptorProto >*
|
||||
CodeGeneratorRequest::mutable_proto_file() {
|
||||
return &proto_file_;
|
||||
}
|
||||
|
||||
// -------------------------------------------------------------------
|
||||
|
||||
// CodeGeneratorResponse_File
|
||||
|
||||
// optional string name = 1;
|
||||
inline bool CodeGeneratorResponse_File::has_name() const {
|
||||
return (_has_bits_[0] & 0x00000001u) != 0;
|
||||
}
|
||||
inline void CodeGeneratorResponse_File::set_has_name() {
|
||||
_has_bits_[0] |= 0x00000001u;
|
||||
}
|
||||
inline void CodeGeneratorResponse_File::clear_has_name() {
|
||||
_has_bits_[0] &= ~0x00000001u;
|
||||
}
|
||||
inline void CodeGeneratorResponse_File::clear_name() {
|
||||
if (name_ != &::google::protobuf::internal::kEmptyString) {
|
||||
name_->clear();
|
||||
}
|
||||
clear_has_name();
|
||||
}
|
||||
inline const ::std::string& CodeGeneratorResponse_File::name() const {
|
||||
return *name_;
|
||||
}
|
||||
inline void CodeGeneratorResponse_File::set_name(const ::std::string& value) {
|
||||
set_has_name();
|
||||
if (name_ == &::google::protobuf::internal::kEmptyString) {
|
||||
name_ = new ::std::string;
|
||||
}
|
||||
name_->assign(value);
|
||||
}
|
||||
inline void CodeGeneratorResponse_File::set_name(const char* value) {
|
||||
set_has_name();
|
||||
if (name_ == &::google::protobuf::internal::kEmptyString) {
|
||||
name_ = new ::std::string;
|
||||
}
|
||||
name_->assign(value);
|
||||
}
|
||||
inline void CodeGeneratorResponse_File::set_name(const char* value, size_t size) {
|
||||
set_has_name();
|
||||
if (name_ == &::google::protobuf::internal::kEmptyString) {
|
||||
name_ = new ::std::string;
|
||||
}
|
||||
name_->assign(reinterpret_cast<const char*>(value), size);
|
||||
}
|
||||
inline ::std::string* CodeGeneratorResponse_File::mutable_name() {
|
||||
set_has_name();
|
||||
if (name_ == &::google::protobuf::internal::kEmptyString) {
|
||||
name_ = new ::std::string;
|
||||
}
|
||||
return name_;
|
||||
}
|
||||
inline ::std::string* CodeGeneratorResponse_File::release_name() {
|
||||
clear_has_name();
|
||||
if (name_ == &::google::protobuf::internal::kEmptyString) {
|
||||
return NULL;
|
||||
} else {
|
||||
::std::string* temp = name_;
|
||||
name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
|
||||
return temp;
|
||||
}
|
||||
}
|
||||
|
||||
// optional string insertion_point = 2;
|
||||
inline bool CodeGeneratorResponse_File::has_insertion_point() const {
|
||||
return (_has_bits_[0] & 0x00000002u) != 0;
|
||||
}
|
||||
inline void CodeGeneratorResponse_File::set_has_insertion_point() {
|
||||
_has_bits_[0] |= 0x00000002u;
|
||||
}
|
||||
inline void CodeGeneratorResponse_File::clear_has_insertion_point() {
|
||||
_has_bits_[0] &= ~0x00000002u;
|
||||
}
|
||||
inline void CodeGeneratorResponse_File::clear_insertion_point() {
|
||||
if (insertion_point_ != &::google::protobuf::internal::kEmptyString) {
|
||||
insertion_point_->clear();
|
||||
}
|
||||
clear_has_insertion_point();
|
||||
}
|
||||
inline const ::std::string& CodeGeneratorResponse_File::insertion_point() const {
|
||||
return *insertion_point_;
|
||||
}
|
||||
inline void CodeGeneratorResponse_File::set_insertion_point(const ::std::string& value) {
|
||||
set_has_insertion_point();
|
||||
if (insertion_point_ == &::google::protobuf::internal::kEmptyString) {
|
||||
insertion_point_ = new ::std::string;
|
||||
}
|
||||
insertion_point_->assign(value);
|
||||
}
|
||||
inline void CodeGeneratorResponse_File::set_insertion_point(const char* value) {
|
||||
set_has_insertion_point();
|
||||
if (insertion_point_ == &::google::protobuf::internal::kEmptyString) {
|
||||
insertion_point_ = new ::std::string;
|
||||
}
|
||||
insertion_point_->assign(value);
|
||||
}
|
||||
inline void CodeGeneratorResponse_File::set_insertion_point(const char* value, size_t size) {
|
||||
set_has_insertion_point();
|
||||
if (insertion_point_ == &::google::protobuf::internal::kEmptyString) {
|
||||
insertion_point_ = new ::std::string;
|
||||
}
|
||||
insertion_point_->assign(reinterpret_cast<const char*>(value), size);
|
||||
}
|
||||
inline ::std::string* CodeGeneratorResponse_File::mutable_insertion_point() {
|
||||
set_has_insertion_point();
|
||||
if (insertion_point_ == &::google::protobuf::internal::kEmptyString) {
|
||||
insertion_point_ = new ::std::string;
|
||||
}
|
||||
return insertion_point_;
|
||||
}
|
||||
inline ::std::string* CodeGeneratorResponse_File::release_insertion_point() {
|
||||
clear_has_insertion_point();
|
||||
if (insertion_point_ == &::google::protobuf::internal::kEmptyString) {
|
||||
return NULL;
|
||||
} else {
|
||||
::std::string* temp = insertion_point_;
|
||||
insertion_point_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
|
||||
return temp;
|
||||
}
|
||||
}
|
||||
|
||||
// optional string content = 15;
|
||||
inline bool CodeGeneratorResponse_File::has_content() const {
|
||||
return (_has_bits_[0] & 0x00000004u) != 0;
|
||||
}
|
||||
inline void CodeGeneratorResponse_File::set_has_content() {
|
||||
_has_bits_[0] |= 0x00000004u;
|
||||
}
|
||||
inline void CodeGeneratorResponse_File::clear_has_content() {
|
||||
_has_bits_[0] &= ~0x00000004u;
|
||||
}
|
||||
inline void CodeGeneratorResponse_File::clear_content() {
|
||||
if (content_ != &::google::protobuf::internal::kEmptyString) {
|
||||
content_->clear();
|
||||
}
|
||||
clear_has_content();
|
||||
}
|
||||
inline const ::std::string& CodeGeneratorResponse_File::content() const {
|
||||
return *content_;
|
||||
}
|
||||
inline void CodeGeneratorResponse_File::set_content(const ::std::string& value) {
|
||||
set_has_content();
|
||||
if (content_ == &::google::protobuf::internal::kEmptyString) {
|
||||
content_ = new ::std::string;
|
||||
}
|
||||
content_->assign(value);
|
||||
}
|
||||
inline void CodeGeneratorResponse_File::set_content(const char* value) {
|
||||
set_has_content();
|
||||
if (content_ == &::google::protobuf::internal::kEmptyString) {
|
||||
content_ = new ::std::string;
|
||||
}
|
||||
content_->assign(value);
|
||||
}
|
||||
inline void CodeGeneratorResponse_File::set_content(const char* value, size_t size) {
|
||||
set_has_content();
|
||||
if (content_ == &::google::protobuf::internal::kEmptyString) {
|
||||
content_ = new ::std::string;
|
||||
}
|
||||
content_->assign(reinterpret_cast<const char*>(value), size);
|
||||
}
|
||||
inline ::std::string* CodeGeneratorResponse_File::mutable_content() {
|
||||
set_has_content();
|
||||
if (content_ == &::google::protobuf::internal::kEmptyString) {
|
||||
content_ = new ::std::string;
|
||||
}
|
||||
return content_;
|
||||
}
|
||||
inline ::std::string* CodeGeneratorResponse_File::release_content() {
|
||||
clear_has_content();
|
||||
if (content_ == &::google::protobuf::internal::kEmptyString) {
|
||||
return NULL;
|
||||
} else {
|
||||
::std::string* temp = content_;
|
||||
content_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
|
||||
return temp;
|
||||
}
|
||||
}
|
||||
|
||||
// -------------------------------------------------------------------
|
||||
|
||||
// CodeGeneratorResponse
|
||||
|
||||
// optional string error = 1;
|
||||
inline bool CodeGeneratorResponse::has_error() const {
|
||||
return (_has_bits_[0] & 0x00000001u) != 0;
|
||||
}
|
||||
inline void CodeGeneratorResponse::set_has_error() {
|
||||
_has_bits_[0] |= 0x00000001u;
|
||||
}
|
||||
inline void CodeGeneratorResponse::clear_has_error() {
|
||||
_has_bits_[0] &= ~0x00000001u;
|
||||
}
|
||||
inline void CodeGeneratorResponse::clear_error() {
|
||||
if (error_ != &::google::protobuf::internal::kEmptyString) {
|
||||
error_->clear();
|
||||
}
|
||||
clear_has_error();
|
||||
}
|
||||
inline const ::std::string& CodeGeneratorResponse::error() const {
|
||||
return *error_;
|
||||
}
|
||||
inline void CodeGeneratorResponse::set_error(const ::std::string& value) {
|
||||
set_has_error();
|
||||
if (error_ == &::google::protobuf::internal::kEmptyString) {
|
||||
error_ = new ::std::string;
|
||||
}
|
||||
error_->assign(value);
|
||||
}
|
||||
inline void CodeGeneratorResponse::set_error(const char* value) {
|
||||
set_has_error();
|
||||
if (error_ == &::google::protobuf::internal::kEmptyString) {
|
||||
error_ = new ::std::string;
|
||||
}
|
||||
error_->assign(value);
|
||||
}
|
||||
inline void CodeGeneratorResponse::set_error(const char* value, size_t size) {
|
||||
set_has_error();
|
||||
if (error_ == &::google::protobuf::internal::kEmptyString) {
|
||||
error_ = new ::std::string;
|
||||
}
|
||||
error_->assign(reinterpret_cast<const char*>(value), size);
|
||||
}
|
||||
inline ::std::string* CodeGeneratorResponse::mutable_error() {
|
||||
set_has_error();
|
||||
if (error_ == &::google::protobuf::internal::kEmptyString) {
|
||||
error_ = new ::std::string;
|
||||
}
|
||||
return error_;
|
||||
}
|
||||
inline ::std::string* CodeGeneratorResponse::release_error() {
|
||||
clear_has_error();
|
||||
if (error_ == &::google::protobuf::internal::kEmptyString) {
|
||||
return NULL;
|
||||
} else {
|
||||
::std::string* temp = error_;
|
||||
error_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
|
||||
return temp;
|
||||
}
|
||||
}
|
||||
|
||||
// repeated .google.protobuf.compiler.CodeGeneratorResponse.File file = 15;
|
||||
inline int CodeGeneratorResponse::file_size() const {
|
||||
return file_.size();
|
||||
}
|
||||
inline void CodeGeneratorResponse::clear_file() {
|
||||
file_.Clear();
|
||||
}
|
||||
inline const ::google::protobuf::compiler::CodeGeneratorResponse_File& CodeGeneratorResponse::file(int index) const {
|
||||
return file_.Get(index);
|
||||
}
|
||||
inline ::google::protobuf::compiler::CodeGeneratorResponse_File* CodeGeneratorResponse::mutable_file(int index) {
|
||||
return file_.Mutable(index);
|
||||
}
|
||||
inline ::google::protobuf::compiler::CodeGeneratorResponse_File* CodeGeneratorResponse::add_file() {
|
||||
return file_.Add();
|
||||
}
|
||||
inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::compiler::CodeGeneratorResponse_File >&
|
||||
CodeGeneratorResponse::file() const {
|
||||
return file_;
|
||||
}
|
||||
inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::compiler::CodeGeneratorResponse_File >*
|
||||
CodeGeneratorResponse::mutable_file() {
|
||||
return &file_;
|
||||
}
|
||||
|
||||
|
||||
// @@protoc_insertion_point(namespace_scope)
|
||||
|
||||
} // namespace compiler
|
||||
} // namespace protobuf
|
||||
} // namespace google
|
||||
|
||||
#ifndef SWIG
|
||||
namespace google {
|
||||
namespace protobuf {
|
||||
|
||||
|
||||
} // namespace google
|
||||
} // namespace protobuf
|
||||
#endif // SWIG
|
||||
|
||||
// @@protoc_insertion_point(global_scope)
|
||||
|
||||
#endif // PROTOBUF_google_2fprotobuf_2fcompiler_2fplugin_2eproto__INCLUDED
|
||||
@ -1,218 +0,0 @@
|
||||
// Protocol Buffers - Google's data interchange format
|
||||
// Copyright 2008 Google Inc. All rights reserved.
|
||||
// http://code.google.com/p/protobuf/
|
||||
//
|
||||
// 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.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// 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.
|
||||
|
||||
// Protocol Buffers - Google's data interchange format
|
||||
// Copyright 2008 Google Inc. All rights reserved.
|
||||
// http://code.google.com/p/protobuf/
|
||||
//
|
||||
// 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.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// 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.
|
||||
|
||||
// Author: ambrose@google.com (Ambrose Feinstein),
|
||||
// kenton@google.com (Kenton Varda)
|
||||
//
|
||||
// Based on http://www.pkware.com/documents/casestudies/APPNOTE.TXT
|
||||
|
||||
#include <google/protobuf/compiler/zip_writer.h>
|
||||
#include <google/protobuf/io/coded_stream.h>
|
||||
|
||||
namespace google {
|
||||
namespace protobuf {
|
||||
namespace compiler {
|
||||
|
||||
static const uint32 kCRC32Table[256] = {
|
||||
0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419, 0x706af48f,
|
||||
0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988,
|
||||
0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91, 0x1db71064, 0x6ab020f2,
|
||||
0xf3b97148, 0x84be41de, 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7,
|
||||
0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
|
||||
0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172,
|
||||
0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b, 0x35b5a8fa, 0x42b2986c,
|
||||
0xdbbbc9d6, 0xacbcf940, 0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59,
|
||||
0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423,
|
||||
0xcfba9599, 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
|
||||
0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190, 0x01db7106,
|
||||
0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433,
|
||||
0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d,
|
||||
0x91646c97, 0xe6635c01, 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e,
|
||||
0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
|
||||
0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65,
|
||||
0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2, 0x4adfa541, 0x3dd895d7,
|
||||
0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0,
|
||||
0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa,
|
||||
0xbe0b1010, 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
|
||||
0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17, 0x2eb40d81,
|
||||
0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a,
|
||||
0xead54739, 0x9dd277af, 0x04db2615, 0x73dc1683, 0xe3630b12, 0x94643b84,
|
||||
0x0d6d6a3e, 0x7a6a5aa8, 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1,
|
||||
0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
|
||||
0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc,
|
||||
0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5, 0xd6d6a3e8, 0xa1d1937e,
|
||||
0x38d8c2c4, 0x4fdff252, 0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b,
|
||||
0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55,
|
||||
0x316e8eef, 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
|
||||
0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe, 0xb2bd0b28,
|
||||
0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d,
|
||||
0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a, 0x9c0906a9, 0xeb0e363f,
|
||||
0x72076785, 0x05005713, 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38,
|
||||
0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
|
||||
0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777,
|
||||
0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c, 0x8f659eff, 0xf862ae69,
|
||||
0x616bffd3, 0x166ccf45, 0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2,
|
||||
0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc,
|
||||
0x40df0b66, 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
|
||||
0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605, 0xcdd70693,
|
||||
0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94,
|
||||
0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d
|
||||
};
|
||||
|
||||
static uint32 ComputeCRC32(const string &buf) {
|
||||
uint32 x = ~0U;
|
||||
for (int i = 0; i < buf.size(); ++i) {
|
||||
unsigned char c = buf[i];
|
||||
x = kCRC32Table[(x ^ c) & 0xff] ^ (x >> 8);
|
||||
}
|
||||
return ~x;
|
||||
}
|
||||
|
||||
static void WriteShort(io::CodedOutputStream *out, uint16 val) {
|
||||
uint8 p[2];
|
||||
p[0] = static_cast<uint8>(val);
|
||||
p[1] = static_cast<uint8>(val >> 8);
|
||||
out->WriteRaw(p, 2);
|
||||
}
|
||||
|
||||
ZipWriter::ZipWriter(io::ZeroCopyOutputStream* raw_output)
|
||||
: raw_output_(raw_output) {}
|
||||
ZipWriter::~ZipWriter() {}
|
||||
|
||||
bool ZipWriter::Write(const string& filename, const string& contents) {
|
||||
FileInfo info;
|
||||
|
||||
info.name = filename;
|
||||
uint16 filename_size = filename.size();
|
||||
info.offset = raw_output_->ByteCount();
|
||||
info.size = contents.size();
|
||||
info.crc32 = ComputeCRC32(contents);
|
||||
|
||||
files_.push_back(info);
|
||||
|
||||
// write file header
|
||||
io::CodedOutputStream output(raw_output_);
|
||||
output.WriteLittleEndian32(0x04034b50); // magic
|
||||
WriteShort(&output, 10); // version needed to extract
|
||||
WriteShort(&output, 0); // flags
|
||||
WriteShort(&output, 0); // compression method: stored
|
||||
WriteShort(&output, 0); // last modified time
|
||||
WriteShort(&output, 0); // last modified date
|
||||
output.WriteLittleEndian32(info.crc32); // crc-32
|
||||
output.WriteLittleEndian32(info.size); // compressed size
|
||||
output.WriteLittleEndian32(info.size); // uncompressed size
|
||||
WriteShort(&output, filename_size); // file name length
|
||||
WriteShort(&output, 0); // extra field length
|
||||
output.WriteString(filename); // file name
|
||||
output.WriteString(contents); // file data
|
||||
|
||||
return !output.HadError();
|
||||
}
|
||||
|
||||
bool ZipWriter::WriteDirectory() {
|
||||
uint16 num_entries = files_.size();
|
||||
uint32 dir_ofs = raw_output_->ByteCount();
|
||||
|
||||
// write central directory
|
||||
io::CodedOutputStream output(raw_output_);
|
||||
for (int i = 0; i < num_entries; ++i) {
|
||||
const string &filename = files_[i].name;
|
||||
uint16 filename_size = filename.size();
|
||||
uint32 crc32 = files_[i].crc32;
|
||||
uint32 size = files_[i].size;
|
||||
uint32 offset = files_[i].offset;
|
||||
|
||||
output.WriteLittleEndian32(0x02014b50); // magic
|
||||
WriteShort(&output, 10); // version made by
|
||||
WriteShort(&output, 10); // version needed to extract
|
||||
WriteShort(&output, 0); // flags
|
||||
WriteShort(&output, 0); // compression method: stored
|
||||
WriteShort(&output, 0); // last modified time
|
||||
WriteShort(&output, 0); // last modified date
|
||||
output.WriteLittleEndian32(crc32); // crc-32
|
||||
output.WriteLittleEndian32(size); // compressed size
|
||||
output.WriteLittleEndian32(size); // uncompressed size
|
||||
WriteShort(&output, filename_size); // file name length
|
||||
WriteShort(&output, 0); // extra field length
|
||||
WriteShort(&output, 0); // file comment length
|
||||
WriteShort(&output, 0); // starting disk number
|
||||
WriteShort(&output, 0); // internal file attributes
|
||||
output.WriteLittleEndian32(0); // external file attributes
|
||||
output.WriteLittleEndian32(offset); // local header offset
|
||||
output.WriteString(filename); // file name
|
||||
}
|
||||
uint32 dir_len = output.ByteCount();
|
||||
|
||||
// write end of central directory marker
|
||||
output.WriteLittleEndian32(0x06054b50); // magic
|
||||
WriteShort(&output, 0); // disk number
|
||||
WriteShort(&output, 0); // disk with start of central directory
|
||||
WriteShort(&output, num_entries); // central directory entries (this disk)
|
||||
WriteShort(&output, num_entries); // central directory entries (total)
|
||||
output.WriteLittleEndian32(dir_len); // central directory byte size
|
||||
output.WriteLittleEndian32(dir_ofs); // central directory offset
|
||||
WriteShort(&output, 0); // comment length
|
||||
|
||||
return output.HadError();
|
||||
}
|
||||
|
||||
} // namespace compiler
|
||||
} // namespace protobuf
|
||||
} // namespace google
|
||||
@ -1,93 +0,0 @@
|
||||
// Protocol Buffers - Google's data interchange format
|
||||
// Copyright 2008 Google Inc. All rights reserved.
|
||||
// http://code.google.com/p/protobuf/
|
||||
//
|
||||
// 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.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// 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.
|
||||
|
||||
// Protocol Buffers - Google's data interchange format
|
||||
// Copyright 2008 Google Inc. All rights reserved.
|
||||
// http://code.google.com/p/protobuf/
|
||||
//
|
||||
// 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.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// 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.
|
||||
|
||||
// Author: kenton@google.com (Kenton Varda)
|
||||
|
||||
#include <vector>
|
||||
#include <google/protobuf/stubs/common.h>
|
||||
#include <google/protobuf/io/zero_copy_stream.h>
|
||||
|
||||
namespace google {
|
||||
namespace protobuf {
|
||||
namespace compiler {
|
||||
|
||||
class ZipWriter {
|
||||
public:
|
||||
ZipWriter(io::ZeroCopyOutputStream* raw_output);
|
||||
~ZipWriter();
|
||||
|
||||
bool Write(const string& filename, const string& contents);
|
||||
bool WriteDirectory();
|
||||
|
||||
private:
|
||||
struct FileInfo {
|
||||
string name;
|
||||
uint32 offset;
|
||||
uint32 size;
|
||||
uint32 crc32;
|
||||
};
|
||||
|
||||
io::ZeroCopyOutputStream* raw_output_;
|
||||
vector<FileInfo> files_;
|
||||
};
|
||||
|
||||
} // namespace compiler
|
||||
} // namespace protobuf
|
||||
} // namespace google
|
||||
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
@ -1,541 +0,0 @@
|
||||
// Protocol Buffers - Google's data interchange format
|
||||
// Copyright 2008 Google Inc. All rights reserved.
|
||||
// http://code.google.com/p/protobuf/
|
||||
//
|
||||
// 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.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// 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.
|
||||
|
||||
// Author: kenton@google.com (Kenton Varda)
|
||||
// Based on original Protocol Buffers design by
|
||||
// Sanjay Ghemawat, Jeff Dean, and others.
|
||||
|
||||
#include <google/protobuf/descriptor_database.h>
|
||||
|
||||
#include <set>
|
||||
|
||||
#include <google/protobuf/descriptor.pb.h>
|
||||
#include <google/protobuf/wire_format_lite_inl.h>
|
||||
#include <google/protobuf/stubs/strutil.h>
|
||||
#include <google/protobuf/stubs/stl_util-inl.h>
|
||||
#include <google/protobuf/stubs/map-util.h>
|
||||
|
||||
namespace google {
|
||||
namespace protobuf {
|
||||
|
||||
DescriptorDatabase::~DescriptorDatabase() {}
|
||||
|
||||
// ===================================================================
|
||||
|
||||
template <typename Value>
|
||||
bool SimpleDescriptorDatabase::DescriptorIndex<Value>::AddFile(
|
||||
const FileDescriptorProto& file,
|
||||
Value value) {
|
||||
if (!InsertIfNotPresent(&by_name_, file.name(), value)) {
|
||||
GOOGLE_LOG(ERROR) << "File already exists in database: " << file.name();
|
||||
return false;
|
||||
}
|
||||
|
||||
// We must be careful here -- calling file.package() if file.has_package() is
|
||||
// false could access an uninitialized static-storage variable if we are being
|
||||
// run at startup time.
|
||||
string path = file.has_package() ? file.package() : string();
|
||||
if (!path.empty()) path += '.';
|
||||
|
||||
for (int i = 0; i < file.message_type_size(); i++) {
|
||||
if (!AddSymbol(path + file.message_type(i).name(), value)) return false;
|
||||
if (!AddNestedExtensions(file.message_type(i), value)) return false;
|
||||
}
|
||||
for (int i = 0; i < file.enum_type_size(); i++) {
|
||||
if (!AddSymbol(path + file.enum_type(i).name(), value)) return false;
|
||||
}
|
||||
for (int i = 0; i < file.extension_size(); i++) {
|
||||
if (!AddSymbol(path + file.extension(i).name(), value)) return false;
|
||||
if (!AddExtension(file.extension(i), value)) return false;
|
||||
}
|
||||
for (int i = 0; i < file.service_size(); i++) {
|
||||
if (!AddSymbol(path + file.service(i).name(), value)) return false;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
template <typename Value>
|
||||
bool SimpleDescriptorDatabase::DescriptorIndex<Value>::AddSymbol(
|
||||
const string& name, Value value) {
|
||||
// We need to make sure not to violate our map invariant.
|
||||
|
||||
// If the symbol name is invalid it could break our lookup algorithm (which
|
||||
// relies on the fact that '.' sorts before all other characters that are
|
||||
// valid in symbol names).
|
||||
if (!ValidateSymbolName(name)) {
|
||||
GOOGLE_LOG(ERROR) << "Invalid symbol name: " << name;
|
||||
return false;
|
||||
}
|
||||
|
||||
// Try to look up the symbol to make sure a super-symbol doesn't already
|
||||
// exist.
|
||||
typename map<string, Value>::iterator iter = FindLastLessOrEqual(name);
|
||||
|
||||
if (iter == by_symbol_.end()) {
|
||||
// Apparently the map is currently empty. Just insert and be done with it.
|
||||
by_symbol_.insert(typename map<string, Value>::value_type(name, value));
|
||||
return true;
|
||||
}
|
||||
|
||||
if (IsSubSymbol(iter->first, name)) {
|
||||
GOOGLE_LOG(ERROR) << "Symbol name \"" << name << "\" conflicts with the existing "
|
||||
"symbol \"" << iter->first << "\".";
|
||||
return false;
|
||||
}
|
||||
|
||||
// OK, that worked. Now we have to make sure that no symbol in the map is
|
||||
// a sub-symbol of the one we are inserting. The only symbol which could
|
||||
// be so is the first symbol that is greater than the new symbol. Since
|
||||
// |iter| points at the last symbol that is less than or equal, we just have
|
||||
// to increment it.
|
||||
++iter;
|
||||
|
||||
if (iter != by_symbol_.end() && IsSubSymbol(name, iter->first)) {
|
||||
GOOGLE_LOG(ERROR) << "Symbol name \"" << name << "\" conflicts with the existing "
|
||||
"symbol \"" << iter->first << "\".";
|
||||
return false;
|
||||
}
|
||||
|
||||
// OK, no conflicts.
|
||||
|
||||
// Insert the new symbol using the iterator as a hint, the new entry will
|
||||
// appear immediately before the one the iterator is pointing at.
|
||||
by_symbol_.insert(iter, typename map<string, Value>::value_type(name, value));
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
template <typename Value>
|
||||
bool SimpleDescriptorDatabase::DescriptorIndex<Value>::AddNestedExtensions(
|
||||
const DescriptorProto& message_type,
|
||||
Value value) {
|
||||
for (int i = 0; i < message_type.nested_type_size(); i++) {
|
||||
if (!AddNestedExtensions(message_type.nested_type(i), value)) return false;
|
||||
}
|
||||
for (int i = 0; i < message_type.extension_size(); i++) {
|
||||
if (!AddExtension(message_type.extension(i), value)) return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
template <typename Value>
|
||||
bool SimpleDescriptorDatabase::DescriptorIndex<Value>::AddExtension(
|
||||
const FieldDescriptorProto& field,
|
||||
Value value) {
|
||||
if (!field.extendee().empty() && field.extendee()[0] == '.') {
|
||||
// The extension is fully-qualified. We can use it as a lookup key in
|
||||
// the by_symbol_ table.
|
||||
if (!InsertIfNotPresent(&by_extension_,
|
||||
make_pair(field.extendee().substr(1),
|
||||
field.number()),
|
||||
value)) {
|
||||
GOOGLE_LOG(ERROR) << "Extension conflicts with extension already in database: "
|
||||
"extend " << field.extendee() << " { "
|
||||
<< field.name() << " = " << field.number() << " }";
|
||||
return false;
|
||||
}
|
||||
} else {
|
||||
// Not fully-qualified. We can't really do anything here, unfortunately.
|
||||
// We don't consider this an error, though, because the descriptor is
|
||||
// valid.
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
template <typename Value>
|
||||
Value SimpleDescriptorDatabase::DescriptorIndex<Value>::FindFile(
|
||||
const string& filename) {
|
||||
return FindWithDefault(by_name_, filename, Value());
|
||||
}
|
||||
|
||||
template <typename Value>
|
||||
Value SimpleDescriptorDatabase::DescriptorIndex<Value>::FindSymbol(
|
||||
const string& name) {
|
||||
typename map<string, Value>::iterator iter = FindLastLessOrEqual(name);
|
||||
|
||||
return (iter != by_symbol_.end() && IsSubSymbol(iter->first, name)) ?
|
||||
iter->second : Value();
|
||||
}
|
||||
|
||||
template <typename Value>
|
||||
Value SimpleDescriptorDatabase::DescriptorIndex<Value>::FindExtension(
|
||||
const string& containing_type,
|
||||
int field_number) {
|
||||
return FindWithDefault(by_extension_,
|
||||
make_pair(containing_type, field_number),
|
||||
Value());
|
||||
}
|
||||
|
||||
template <typename Value>
|
||||
bool SimpleDescriptorDatabase::DescriptorIndex<Value>::FindAllExtensionNumbers(
|
||||
const string& containing_type,
|
||||
vector<int>* output) {
|
||||
typename map<pair<string, int>, Value >::const_iterator it =
|
||||
by_extension_.lower_bound(make_pair(containing_type, 0));
|
||||
bool success = false;
|
||||
|
||||
for (; it != by_extension_.end() && it->first.first == containing_type;
|
||||
++it) {
|
||||
output->push_back(it->first.second);
|
||||
success = true;
|
||||
}
|
||||
|
||||
return success;
|
||||
}
|
||||
|
||||
template <typename Value>
|
||||
typename map<string, Value>::iterator
|
||||
SimpleDescriptorDatabase::DescriptorIndex<Value>::FindLastLessOrEqual(
|
||||
const string& name) {
|
||||
// Find the last key in the map which sorts less than or equal to the
|
||||
// symbol name. Since upper_bound() returns the *first* key that sorts
|
||||
// *greater* than the input, we want the element immediately before that.
|
||||
typename map<string, Value>::iterator iter = by_symbol_.upper_bound(name);
|
||||
if (iter != by_symbol_.begin()) --iter;
|
||||
return iter;
|
||||
}
|
||||
|
||||
template <typename Value>
|
||||
bool SimpleDescriptorDatabase::DescriptorIndex<Value>::IsSubSymbol(
|
||||
const string& sub_symbol, const string& super_symbol) {
|
||||
return sub_symbol == super_symbol ||
|
||||
(HasPrefixString(super_symbol, sub_symbol) &&
|
||||
super_symbol[sub_symbol.size()] == '.');
|
||||
}
|
||||
|
||||
template <typename Value>
|
||||
bool SimpleDescriptorDatabase::DescriptorIndex<Value>::ValidateSymbolName(
|
||||
const string& name) {
|
||||
for (int i = 0; i < name.size(); i++) {
|
||||
// I don't trust ctype.h due to locales. :(
|
||||
if (name[i] != '.' && name[i] != '_' &&
|
||||
(name[i] < '0' || name[i] > '9') &&
|
||||
(name[i] < 'A' || name[i] > 'Z') &&
|
||||
(name[i] < 'a' || name[i] > 'z')) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
// -------------------------------------------------------------------
|
||||
|
||||
SimpleDescriptorDatabase::SimpleDescriptorDatabase() {}
|
||||
SimpleDescriptorDatabase::~SimpleDescriptorDatabase() {
|
||||
STLDeleteElements(&files_to_delete_);
|
||||
}
|
||||
|
||||
bool SimpleDescriptorDatabase::Add(const FileDescriptorProto& file) {
|
||||
FileDescriptorProto* new_file = new FileDescriptorProto;
|
||||
new_file->CopyFrom(file);
|
||||
return AddAndOwn(new_file);
|
||||
}
|
||||
|
||||
bool SimpleDescriptorDatabase::AddAndOwn(const FileDescriptorProto* file) {
|
||||
files_to_delete_.push_back(file);
|
||||
return index_.AddFile(*file, file);
|
||||
}
|
||||
|
||||
bool SimpleDescriptorDatabase::FindFileByName(
|
||||
const string& filename,
|
||||
FileDescriptorProto* output) {
|
||||
return MaybeCopy(index_.FindFile(filename), output);
|
||||
}
|
||||
|
||||
bool SimpleDescriptorDatabase::FindFileContainingSymbol(
|
||||
const string& symbol_name,
|
||||
FileDescriptorProto* output) {
|
||||
return MaybeCopy(index_.FindSymbol(symbol_name), output);
|
||||
}
|
||||
|
||||
bool SimpleDescriptorDatabase::FindFileContainingExtension(
|
||||
const string& containing_type,
|
||||
int field_number,
|
||||
FileDescriptorProto* output) {
|
||||
return MaybeCopy(index_.FindExtension(containing_type, field_number), output);
|
||||
}
|
||||
|
||||
bool SimpleDescriptorDatabase::FindAllExtensionNumbers(
|
||||
const string& extendee_type,
|
||||
vector<int>* output) {
|
||||
return index_.FindAllExtensionNumbers(extendee_type, output);
|
||||
}
|
||||
|
||||
bool SimpleDescriptorDatabase::MaybeCopy(const FileDescriptorProto* file,
|
||||
FileDescriptorProto* output) {
|
||||
if (file == NULL) return false;
|
||||
output->CopyFrom(*file);
|
||||
return true;
|
||||
}
|
||||
|
||||
// -------------------------------------------------------------------
|
||||
|
||||
EncodedDescriptorDatabase::EncodedDescriptorDatabase() {}
|
||||
EncodedDescriptorDatabase::~EncodedDescriptorDatabase() {
|
||||
for (int i = 0; i < files_to_delete_.size(); i++) {
|
||||
operator delete(files_to_delete_[i]);
|
||||
}
|
||||
}
|
||||
|
||||
bool EncodedDescriptorDatabase::Add(
|
||||
const void* encoded_file_descriptor, int size) {
|
||||
FileDescriptorProto file;
|
||||
if (file.ParseFromArray(encoded_file_descriptor, size)) {
|
||||
return index_.AddFile(file, make_pair(encoded_file_descriptor, size));
|
||||
} else {
|
||||
GOOGLE_LOG(ERROR) << "Invalid file descriptor data passed to "
|
||||
"EncodedDescriptorDatabase::Add().";
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
bool EncodedDescriptorDatabase::AddCopy(
|
||||
const void* encoded_file_descriptor, int size) {
|
||||
void* copy = operator new(size);
|
||||
memcpy(copy, encoded_file_descriptor, size);
|
||||
files_to_delete_.push_back(copy);
|
||||
return Add(copy, size);
|
||||
}
|
||||
|
||||
bool EncodedDescriptorDatabase::FindFileByName(
|
||||
const string& filename,
|
||||
FileDescriptorProto* output) {
|
||||
return MaybeParse(index_.FindFile(filename), output);
|
||||
}
|
||||
|
||||
bool EncodedDescriptorDatabase::FindFileContainingSymbol(
|
||||
const string& symbol_name,
|
||||
FileDescriptorProto* output) {
|
||||
return MaybeParse(index_.FindSymbol(symbol_name), output);
|
||||
}
|
||||
|
||||
bool EncodedDescriptorDatabase::FindNameOfFileContainingSymbol(
|
||||
const string& symbol_name,
|
||||
string* output) {
|
||||
pair<const void*, int> encoded_file = index_.FindSymbol(symbol_name);
|
||||
if (encoded_file.first == NULL) return false;
|
||||
|
||||
// Optimization: The name should be the first field in the encoded message.
|
||||
// Try to just read it directly.
|
||||
io::CodedInputStream input(reinterpret_cast<const uint8*>(encoded_file.first),
|
||||
encoded_file.second);
|
||||
|
||||
const uint32 kNameTag = internal::WireFormatLite::MakeTag(
|
||||
FileDescriptorProto::kNameFieldNumber,
|
||||
internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED);
|
||||
|
||||
if (input.ReadTag() == kNameTag) {
|
||||
// Success!
|
||||
return internal::WireFormatLite::ReadString(&input, output);
|
||||
} else {
|
||||
// Slow path. Parse whole message.
|
||||
FileDescriptorProto file_proto;
|
||||
if (!file_proto.ParseFromArray(encoded_file.first, encoded_file.second)) {
|
||||
return false;
|
||||
}
|
||||
*output = file_proto.name();
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
bool EncodedDescriptorDatabase::FindFileContainingExtension(
|
||||
const string& containing_type,
|
||||
int field_number,
|
||||
FileDescriptorProto* output) {
|
||||
return MaybeParse(index_.FindExtension(containing_type, field_number),
|
||||
output);
|
||||
}
|
||||
|
||||
bool EncodedDescriptorDatabase::FindAllExtensionNumbers(
|
||||
const string& extendee_type,
|
||||
vector<int>* output) {
|
||||
return index_.FindAllExtensionNumbers(extendee_type, output);
|
||||
}
|
||||
|
||||
bool EncodedDescriptorDatabase::MaybeParse(
|
||||
pair<const void*, int> encoded_file,
|
||||
FileDescriptorProto* output) {
|
||||
if (encoded_file.first == NULL) return false;
|
||||
return output->ParseFromArray(encoded_file.first, encoded_file.second);
|
||||
}
|
||||
|
||||
// ===================================================================
|
||||
|
||||
DescriptorPoolDatabase::DescriptorPoolDatabase(const DescriptorPool& pool)
|
||||
: pool_(pool) {}
|
||||
DescriptorPoolDatabase::~DescriptorPoolDatabase() {}
|
||||
|
||||
bool DescriptorPoolDatabase::FindFileByName(
|
||||
const string& filename,
|
||||
FileDescriptorProto* output) {
|
||||
const FileDescriptor* file = pool_.FindFileByName(filename);
|
||||
if (file == NULL) return false;
|
||||
output->Clear();
|
||||
file->CopyTo(output);
|
||||
return true;
|
||||
}
|
||||
|
||||
bool DescriptorPoolDatabase::FindFileContainingSymbol(
|
||||
const string& symbol_name,
|
||||
FileDescriptorProto* output) {
|
||||
const FileDescriptor* file = pool_.FindFileContainingSymbol(symbol_name);
|
||||
if (file == NULL) return false;
|
||||
output->Clear();
|
||||
file->CopyTo(output);
|
||||
return true;
|
||||
}
|
||||
|
||||
bool DescriptorPoolDatabase::FindFileContainingExtension(
|
||||
const string& containing_type,
|
||||
int field_number,
|
||||
FileDescriptorProto* output) {
|
||||
const Descriptor* extendee = pool_.FindMessageTypeByName(containing_type);
|
||||
if (extendee == NULL) return false;
|
||||
|
||||
const FieldDescriptor* extension =
|
||||
pool_.FindExtensionByNumber(extendee, field_number);
|
||||
if (extension == NULL) return false;
|
||||
|
||||
output->Clear();
|
||||
extension->file()->CopyTo(output);
|
||||
return true;
|
||||
}
|
||||
|
||||
bool DescriptorPoolDatabase::FindAllExtensionNumbers(
|
||||
const string& extendee_type,
|
||||
vector<int>* output) {
|
||||
const Descriptor* extendee = pool_.FindMessageTypeByName(extendee_type);
|
||||
if (extendee == NULL) return false;
|
||||
|
||||
vector<const FieldDescriptor*> extensions;
|
||||
pool_.FindAllExtensions(extendee, &extensions);
|
||||
|
||||
for (int i = 0; i < extensions.size(); ++i) {
|
||||
output->push_back(extensions[i]->number());
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
// ===================================================================
|
||||
|
||||
MergedDescriptorDatabase::MergedDescriptorDatabase(
|
||||
DescriptorDatabase* source1,
|
||||
DescriptorDatabase* source2) {
|
||||
sources_.push_back(source1);
|
||||
sources_.push_back(source2);
|
||||
}
|
||||
MergedDescriptorDatabase::MergedDescriptorDatabase(
|
||||
const vector<DescriptorDatabase*>& sources)
|
||||
: sources_(sources) {}
|
||||
MergedDescriptorDatabase::~MergedDescriptorDatabase() {}
|
||||
|
||||
bool MergedDescriptorDatabase::FindFileByName(
|
||||
const string& filename,
|
||||
FileDescriptorProto* output) {
|
||||
for (int i = 0; i < sources_.size(); i++) {
|
||||
if (sources_[i]->FindFileByName(filename, output)) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
bool MergedDescriptorDatabase::FindFileContainingSymbol(
|
||||
const string& symbol_name,
|
||||
FileDescriptorProto* output) {
|
||||
for (int i = 0; i < sources_.size(); i++) {
|
||||
if (sources_[i]->FindFileContainingSymbol(symbol_name, output)) {
|
||||
// The symbol was found in source i. However, if one of the previous
|
||||
// sources defines a file with the same name (which presumably doesn't
|
||||
// contain the symbol, since it wasn't found in that source), then we
|
||||
// must hide it from the caller.
|
||||
FileDescriptorProto temp;
|
||||
for (int j = 0; j < i; j++) {
|
||||
if (sources_[j]->FindFileByName(output->name(), &temp)) {
|
||||
// Found conflicting file in a previous source.
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
bool MergedDescriptorDatabase::FindFileContainingExtension(
|
||||
const string& containing_type,
|
||||
int field_number,
|
||||
FileDescriptorProto* output) {
|
||||
for (int i = 0; i < sources_.size(); i++) {
|
||||
if (sources_[i]->FindFileContainingExtension(
|
||||
containing_type, field_number, output)) {
|
||||
// The symbol was found in source i. However, if one of the previous
|
||||
// sources defines a file with the same name (which presumably doesn't
|
||||
// contain the symbol, since it wasn't found in that source), then we
|
||||
// must hide it from the caller.
|
||||
FileDescriptorProto temp;
|
||||
for (int j = 0; j < i; j++) {
|
||||
if (sources_[j]->FindFileByName(output->name(), &temp)) {
|
||||
// Found conflicting file in a previous source.
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
bool MergedDescriptorDatabase::FindAllExtensionNumbers(
|
||||
const string& extendee_type,
|
||||
vector<int>* output) {
|
||||
set<int> merged_results;
|
||||
vector<int> results;
|
||||
bool success = false;
|
||||
|
||||
for (int i = 0; i < sources_.size(); i++) {
|
||||
if (sources_[i]->FindAllExtensionNumbers(extendee_type, &results)) {
|
||||
copy(results.begin(), results.end(),
|
||||
insert_iterator<set<int> >(merged_results, merged_results.begin()));
|
||||
success = true;
|
||||
}
|
||||
results.clear();
|
||||
}
|
||||
|
||||
copy(merged_results.begin(), merged_results.end(),
|
||||
insert_iterator<vector<int> >(*output, output->end()));
|
||||
|
||||
return success;
|
||||
}
|
||||
|
||||
} // namespace protobuf
|
||||
} // namespace google
|
||||
@ -1,558 +0,0 @@
|
||||
// Protocol Buffers - Google's data interchange format
|
||||
// Copyright 2008 Google Inc. All rights reserved.
|
||||
// http://code.google.com/p/protobuf/
|
||||
//
|
||||
// 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.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// 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.
|
||||
|
||||
// Author: kenton@google.com (Kenton Varda)
|
||||
// Based on original Protocol Buffers design by
|
||||
// Sanjay Ghemawat, Jeff Dean, and others.
|
||||
//
|
||||
// DynamicMessage is implemented by constructing a data structure which
|
||||
// has roughly the same memory layout as a generated message would have.
|
||||
// Then, we use GeneratedMessageReflection to implement our reflection
|
||||
// interface. All the other operations we need to implement (e.g.
|
||||
// parsing, copying, etc.) are already implemented in terms of
|
||||
// Reflection, so the rest is easy.
|
||||
//
|
||||
// The up side of this strategy is that it's very efficient. We don't
|
||||
// need to use hash_maps or generic representations of fields. The
|
||||
// down side is that this is a low-level memory management hack which
|
||||
// can be tricky to get right.
|
||||
//
|
||||
// As mentioned in the header, we only expose a DynamicMessageFactory
|
||||
// publicly, not the DynamicMessage class itself. This is because
|
||||
// GenericMessageReflection wants to have a pointer to a "default"
|
||||
// copy of the class, with all fields initialized to their default
|
||||
// values. We only want to construct one of these per message type,
|
||||
// so DynamicMessageFactory stores a cache of default messages for
|
||||
// each type it sees (each unique Descriptor pointer). The code
|
||||
// refers to the "default" copy of the class as the "prototype".
|
||||
//
|
||||
// Note on memory allocation: This module often calls "operator new()"
|
||||
// to allocate untyped memory, rather than calling something like
|
||||
// "new uint8[]". This is because "operator new()" means "Give me some
|
||||
// space which I can use as I please." while "new uint8[]" means "Give
|
||||
// me an array of 8-bit integers.". In practice, the later may return
|
||||
// a pointer that is not aligned correctly for general use. I believe
|
||||
// Item 8 of "More Effective C++" discusses this in more detail, though
|
||||
// I don't have the book on me right now so I'm not sure.
|
||||
|
||||
#include <algorithm>
|
||||
#include <google/protobuf/stubs/hash.h>
|
||||
|
||||
#include <google/protobuf/stubs/common.h>
|
||||
|
||||
#include <google/protobuf/dynamic_message.h>
|
||||
#include <google/protobuf/descriptor.h>
|
||||
#include <google/protobuf/descriptor.pb.h>
|
||||
#include <google/protobuf/generated_message_util.h>
|
||||
#include <google/protobuf/generated_message_reflection.h>
|
||||
#include <google/protobuf/reflection_ops.h>
|
||||
#include <google/protobuf/repeated_field.h>
|
||||
#include <google/protobuf/extension_set.h>
|
||||
#include <google/protobuf/wire_format.h>
|
||||
|
||||
namespace google {
|
||||
namespace protobuf {
|
||||
|
||||
using internal::WireFormat;
|
||||
using internal::ExtensionSet;
|
||||
using internal::GeneratedMessageReflection;
|
||||
|
||||
|
||||
// ===================================================================
|
||||
// Some helper tables and functions...
|
||||
|
||||
namespace {
|
||||
|
||||
// Compute the byte size of the in-memory representation of the field.
|
||||
int FieldSpaceUsed(const FieldDescriptor* field) {
|
||||
typedef FieldDescriptor FD; // avoid line wrapping
|
||||
if (field->label() == FD::LABEL_REPEATED) {
|
||||
switch (field->cpp_type()) {
|
||||
case FD::CPPTYPE_INT32 : return sizeof(RepeatedField<int32 >);
|
||||
case FD::CPPTYPE_INT64 : return sizeof(RepeatedField<int64 >);
|
||||
case FD::CPPTYPE_UINT32 : return sizeof(RepeatedField<uint32 >);
|
||||
case FD::CPPTYPE_UINT64 : return sizeof(RepeatedField<uint64 >);
|
||||
case FD::CPPTYPE_DOUBLE : return sizeof(RepeatedField<double >);
|
||||
case FD::CPPTYPE_FLOAT : return sizeof(RepeatedField<float >);
|
||||
case FD::CPPTYPE_BOOL : return sizeof(RepeatedField<bool >);
|
||||
case FD::CPPTYPE_ENUM : return sizeof(RepeatedField<int >);
|
||||
case FD::CPPTYPE_MESSAGE: return sizeof(RepeatedPtrField<Message>);
|
||||
|
||||
case FD::CPPTYPE_STRING:
|
||||
switch (field->options().ctype()) {
|
||||
default: // TODO(kenton): Support other string reps.
|
||||
case FieldOptions::STRING:
|
||||
return sizeof(RepeatedPtrField<string>);
|
||||
}
|
||||
break;
|
||||
}
|
||||
} else {
|
||||
switch (field->cpp_type()) {
|
||||
case FD::CPPTYPE_INT32 : return sizeof(int32 );
|
||||
case FD::CPPTYPE_INT64 : return sizeof(int64 );
|
||||
case FD::CPPTYPE_UINT32 : return sizeof(uint32 );
|
||||
case FD::CPPTYPE_UINT64 : return sizeof(uint64 );
|
||||
case FD::CPPTYPE_DOUBLE : return sizeof(double );
|
||||
case FD::CPPTYPE_FLOAT : return sizeof(float );
|
||||
case FD::CPPTYPE_BOOL : return sizeof(bool );
|
||||
case FD::CPPTYPE_ENUM : return sizeof(int );
|
||||
case FD::CPPTYPE_MESSAGE: return sizeof(Message*);
|
||||
|
||||
case FD::CPPTYPE_STRING:
|
||||
switch (field->options().ctype()) {
|
||||
default: // TODO(kenton): Support other string reps.
|
||||
case FieldOptions::STRING:
|
||||
return sizeof(string*);
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
GOOGLE_LOG(DFATAL) << "Can't get here.";
|
||||
return 0;
|
||||
}
|
||||
|
||||
inline int DivideRoundingUp(int i, int j) {
|
||||
return (i + (j - 1)) / j;
|
||||
}
|
||||
|
||||
static const int kSafeAlignment = sizeof(uint64);
|
||||
|
||||
inline int AlignTo(int offset, int alignment) {
|
||||
return DivideRoundingUp(offset, alignment) * alignment;
|
||||
}
|
||||
|
||||
// Rounds the given byte offset up to the next offset aligned such that any
|
||||
// type may be stored at it.
|
||||
inline int AlignOffset(int offset) {
|
||||
return AlignTo(offset, kSafeAlignment);
|
||||
}
|
||||
|
||||
#define bitsizeof(T) (sizeof(T) * 8)
|
||||
|
||||
} // namespace
|
||||
|
||||
// ===================================================================
|
||||
|
||||
class DynamicMessage : public Message {
|
||||
public:
|
||||
struct TypeInfo {
|
||||
int size;
|
||||
int has_bits_offset;
|
||||
int unknown_fields_offset;
|
||||
int extensions_offset;
|
||||
|
||||
// Not owned by the TypeInfo.
|
||||
DynamicMessageFactory* factory; // The factory that created this object.
|
||||
const DescriptorPool* pool; // The factory's DescriptorPool.
|
||||
const Descriptor* type; // Type of this DynamicMessage.
|
||||
|
||||
// Warning: The order in which the following pointers are defined is
|
||||
// important (the prototype must be deleted *before* the offsets).
|
||||
scoped_array<int> offsets;
|
||||
scoped_ptr<const GeneratedMessageReflection> reflection;
|
||||
scoped_ptr<const DynamicMessage> prototype;
|
||||
};
|
||||
|
||||
DynamicMessage(const TypeInfo* type_info);
|
||||
~DynamicMessage();
|
||||
|
||||
// Called on the prototype after construction to initialize message fields.
|
||||
void CrossLinkPrototypes();
|
||||
|
||||
// implements Message ----------------------------------------------
|
||||
|
||||
Message* New() const;
|
||||
|
||||
int GetCachedSize() const;
|
||||
void SetCachedSize(int size) const;
|
||||
|
||||
Metadata GetMetadata() const;
|
||||
|
||||
private:
|
||||
GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(DynamicMessage);
|
||||
|
||||
inline bool is_prototype() const {
|
||||
return type_info_->prototype == this ||
|
||||
// If type_info_->prototype is NULL, then we must be constructing
|
||||
// the prototype now, which means we must be the prototype.
|
||||
type_info_->prototype == NULL;
|
||||
}
|
||||
|
||||
inline void* OffsetToPointer(int offset) {
|
||||
return reinterpret_cast<uint8*>(this) + offset;
|
||||
}
|
||||
inline const void* OffsetToPointer(int offset) const {
|
||||
return reinterpret_cast<const uint8*>(this) + offset;
|
||||
}
|
||||
|
||||
const TypeInfo* type_info_;
|
||||
|
||||
// TODO(kenton): Make this an atomic<int> when C++ supports it.
|
||||
mutable int cached_byte_size_;
|
||||
};
|
||||
|
||||
DynamicMessage::DynamicMessage(const TypeInfo* type_info)
|
||||
: type_info_(type_info),
|
||||
cached_byte_size_(0) {
|
||||
// We need to call constructors for various fields manually and set
|
||||
// default values where appropriate. We use placement new to call
|
||||
// constructors. If you haven't heard of placement new, I suggest Googling
|
||||
// it now. We use placement new even for primitive types that don't have
|
||||
// constructors for consistency. (In theory, placement new should be used
|
||||
// any time you are trying to convert untyped memory to typed memory, though
|
||||
// in practice that's not strictly necessary for types that don't have a
|
||||
// constructor.)
|
||||
|
||||
const Descriptor* descriptor = type_info_->type;
|
||||
|
||||
new(OffsetToPointer(type_info_->unknown_fields_offset)) UnknownFieldSet;
|
||||
|
||||
if (type_info_->extensions_offset != -1) {
|
||||
new(OffsetToPointer(type_info_->extensions_offset)) ExtensionSet;
|
||||
}
|
||||
|
||||
for (int i = 0; i < descriptor->field_count(); i++) {
|
||||
const FieldDescriptor* field = descriptor->field(i);
|
||||
void* field_ptr = OffsetToPointer(type_info_->offsets[i]);
|
||||
switch (field->cpp_type()) {
|
||||
#define HANDLE_TYPE(CPPTYPE, TYPE) \
|
||||
case FieldDescriptor::CPPTYPE_##CPPTYPE: \
|
||||
if (!field->is_repeated()) { \
|
||||
new(field_ptr) TYPE(field->default_value_##TYPE()); \
|
||||
} else { \
|
||||
new(field_ptr) RepeatedField<TYPE>(); \
|
||||
} \
|
||||
break;
|
||||
|
||||
HANDLE_TYPE(INT32 , int32 );
|
||||
HANDLE_TYPE(INT64 , int64 );
|
||||
HANDLE_TYPE(UINT32, uint32);
|
||||
HANDLE_TYPE(UINT64, uint64);
|
||||
HANDLE_TYPE(DOUBLE, double);
|
||||
HANDLE_TYPE(FLOAT , float );
|
||||
HANDLE_TYPE(BOOL , bool );
|
||||
#undef HANDLE_TYPE
|
||||
|
||||
case FieldDescriptor::CPPTYPE_ENUM:
|
||||
if (!field->is_repeated()) {
|
||||
new(field_ptr) int(field->default_value_enum()->number());
|
||||
} else {
|
||||
new(field_ptr) RepeatedField<int>();
|
||||
}
|
||||
break;
|
||||
|
||||
case FieldDescriptor::CPPTYPE_STRING:
|
||||
switch (field->options().ctype()) {
|
||||
default: // TODO(kenton): Support other string reps.
|
||||
case FieldOptions::STRING:
|
||||
if (!field->is_repeated()) {
|
||||
if (is_prototype()) {
|
||||
new(field_ptr) const string*(&field->default_value_string());
|
||||
} else {
|
||||
string* default_value =
|
||||
*reinterpret_cast<string* const*>(
|
||||
type_info_->prototype->OffsetToPointer(
|
||||
type_info_->offsets[i]));
|
||||
new(field_ptr) string*(default_value);
|
||||
}
|
||||
} else {
|
||||
new(field_ptr) RepeatedPtrField<string>();
|
||||
}
|
||||
break;
|
||||
}
|
||||
break;
|
||||
|
||||
case FieldDescriptor::CPPTYPE_MESSAGE: {
|
||||
if (!field->is_repeated()) {
|
||||
new(field_ptr) Message*(NULL);
|
||||
} else {
|
||||
new(field_ptr) RepeatedPtrField<Message>();
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
DynamicMessage::~DynamicMessage() {
|
||||
const Descriptor* descriptor = type_info_->type;
|
||||
|
||||
reinterpret_cast<UnknownFieldSet*>(
|
||||
OffsetToPointer(type_info_->unknown_fields_offset))->~UnknownFieldSet();
|
||||
|
||||
if (type_info_->extensions_offset != -1) {
|
||||
reinterpret_cast<ExtensionSet*>(
|
||||
OffsetToPointer(type_info_->extensions_offset))->~ExtensionSet();
|
||||
}
|
||||
|
||||
// We need to manually run the destructors for repeated fields and strings,
|
||||
// just as we ran their constructors in the the DynamicMessage constructor.
|
||||
// Additionally, if any singular embedded messages have been allocated, we
|
||||
// need to delete them, UNLESS we are the prototype message of this type,
|
||||
// in which case any embedded messages are other prototypes and shouldn't
|
||||
// be touched.
|
||||
for (int i = 0; i < descriptor->field_count(); i++) {
|
||||
const FieldDescriptor* field = descriptor->field(i);
|
||||
void* field_ptr = OffsetToPointer(type_info_->offsets[i]);
|
||||
|
||||
if (field->is_repeated()) {
|
||||
switch (field->cpp_type()) {
|
||||
#define HANDLE_TYPE(UPPERCASE, LOWERCASE) \
|
||||
case FieldDescriptor::CPPTYPE_##UPPERCASE : \
|
||||
reinterpret_cast<RepeatedField<LOWERCASE>*>(field_ptr) \
|
||||
->~RepeatedField<LOWERCASE>(); \
|
||||
break
|
||||
|
||||
HANDLE_TYPE( INT32, int32);
|
||||
HANDLE_TYPE( INT64, int64);
|
||||
HANDLE_TYPE(UINT32, uint32);
|
||||
HANDLE_TYPE(UINT64, uint64);
|
||||
HANDLE_TYPE(DOUBLE, double);
|
||||
HANDLE_TYPE( FLOAT, float);
|
||||
HANDLE_TYPE( BOOL, bool);
|
||||
HANDLE_TYPE( ENUM, int);
|
||||
#undef HANDLE_TYPE
|
||||
|
||||
case FieldDescriptor::CPPTYPE_STRING:
|
||||
switch (field->options().ctype()) {
|
||||
default: // TODO(kenton): Support other string reps.
|
||||
case FieldOptions::STRING:
|
||||
reinterpret_cast<RepeatedPtrField<string>*>(field_ptr)
|
||||
->~RepeatedPtrField<string>();
|
||||
break;
|
||||
}
|
||||
break;
|
||||
|
||||
case FieldDescriptor::CPPTYPE_MESSAGE:
|
||||
reinterpret_cast<RepeatedPtrField<Message>*>(field_ptr)
|
||||
->~RepeatedPtrField<Message>();
|
||||
break;
|
||||
}
|
||||
|
||||
} else if (field->cpp_type() == FieldDescriptor::CPPTYPE_STRING) {
|
||||
switch (field->options().ctype()) {
|
||||
default: // TODO(kenton): Support other string reps.
|
||||
case FieldOptions::STRING: {
|
||||
string* ptr = *reinterpret_cast<string**>(field_ptr);
|
||||
if (ptr != &field->default_value_string()) {
|
||||
delete ptr;
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
} else if ((field->cpp_type() == FieldDescriptor::CPPTYPE_MESSAGE) &&
|
||||
!is_prototype()) {
|
||||
Message* message = *reinterpret_cast<Message**>(field_ptr);
|
||||
if (message != NULL) {
|
||||
delete message;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void DynamicMessage::CrossLinkPrototypes() {
|
||||
// This should only be called on the prototype message.
|
||||
GOOGLE_CHECK(is_prototype());
|
||||
|
||||
DynamicMessageFactory* factory = type_info_->factory;
|
||||
const Descriptor* descriptor = type_info_->type;
|
||||
|
||||
// Cross-link default messages.
|
||||
for (int i = 0; i < descriptor->field_count(); i++) {
|
||||
const FieldDescriptor* field = descriptor->field(i);
|
||||
void* field_ptr = OffsetToPointer(type_info_->offsets[i]);
|
||||
|
||||
if (field->cpp_type() == FieldDescriptor::CPPTYPE_MESSAGE &&
|
||||
!field->is_repeated()) {
|
||||
// For fields with message types, we need to cross-link with the
|
||||
// prototype for the field's type.
|
||||
// For singular fields, the field is just a pointer which should
|
||||
// point to the prototype.
|
||||
*reinterpret_cast<const Message**>(field_ptr) =
|
||||
factory->GetPrototypeNoLock(field->message_type());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Message* DynamicMessage::New() const {
|
||||
void* new_base = reinterpret_cast<uint8*>(operator new(type_info_->size));
|
||||
memset(new_base, 0, type_info_->size);
|
||||
return new(new_base) DynamicMessage(type_info_);
|
||||
}
|
||||
|
||||
int DynamicMessage::GetCachedSize() const {
|
||||
return cached_byte_size_;
|
||||
}
|
||||
|
||||
void DynamicMessage::SetCachedSize(int size) const {
|
||||
// This is theoretically not thread-compatible, but in practice it works
|
||||
// because if multiple threads write this simultaneously, they will be
|
||||
// writing the exact same value.
|
||||
cached_byte_size_ = size;
|
||||
}
|
||||
|
||||
Metadata DynamicMessage::GetMetadata() const {
|
||||
Metadata metadata;
|
||||
metadata.descriptor = type_info_->type;
|
||||
metadata.reflection = type_info_->reflection.get();
|
||||
return metadata;
|
||||
}
|
||||
|
||||
// ===================================================================
|
||||
|
||||
struct DynamicMessageFactory::PrototypeMap {
|
||||
typedef hash_map<const Descriptor*, const DynamicMessage::TypeInfo*> Map;
|
||||
Map map_;
|
||||
};
|
||||
|
||||
DynamicMessageFactory::DynamicMessageFactory()
|
||||
: pool_(NULL), delegate_to_generated_factory_(false),
|
||||
prototypes_(new PrototypeMap) {
|
||||
}
|
||||
|
||||
DynamicMessageFactory::DynamicMessageFactory(const DescriptorPool* pool)
|
||||
: pool_(pool), delegate_to_generated_factory_(false),
|
||||
prototypes_(new PrototypeMap) {
|
||||
}
|
||||
|
||||
DynamicMessageFactory::~DynamicMessageFactory() {
|
||||
for (PrototypeMap::Map::iterator iter = prototypes_->map_.begin();
|
||||
iter != prototypes_->map_.end(); ++iter) {
|
||||
delete iter->second;
|
||||
}
|
||||
}
|
||||
|
||||
const Message* DynamicMessageFactory::GetPrototype(const Descriptor* type) {
|
||||
MutexLock lock(&prototypes_mutex_);
|
||||
return GetPrototypeNoLock(type);
|
||||
}
|
||||
|
||||
const Message* DynamicMessageFactory::GetPrototypeNoLock(
|
||||
const Descriptor* type) {
|
||||
if (delegate_to_generated_factory_ &&
|
||||
type->file()->pool() == DescriptorPool::generated_pool()) {
|
||||
return MessageFactory::generated_factory()->GetPrototype(type);
|
||||
}
|
||||
|
||||
const DynamicMessage::TypeInfo** target = &prototypes_->map_[type];
|
||||
if (*target != NULL) {
|
||||
// Already exists.
|
||||
return (*target)->prototype.get();
|
||||
}
|
||||
|
||||
DynamicMessage::TypeInfo* type_info = new DynamicMessage::TypeInfo;
|
||||
*target = type_info;
|
||||
|
||||
type_info->type = type;
|
||||
type_info->pool = (pool_ == NULL) ? type->file()->pool() : pool_;
|
||||
type_info->factory = this;
|
||||
|
||||
// We need to construct all the structures passed to
|
||||
// GeneratedMessageReflection's constructor. This includes:
|
||||
// - A block of memory that contains space for all the message's fields.
|
||||
// - An array of integers indicating the byte offset of each field within
|
||||
// this block.
|
||||
// - A big bitfield containing a bit for each field indicating whether
|
||||
// or not that field is set.
|
||||
|
||||
// Compute size and offsets.
|
||||
int* offsets = new int[type->field_count()];
|
||||
type_info->offsets.reset(offsets);
|
||||
|
||||
// Decide all field offsets by packing in order.
|
||||
// We place the DynamicMessage object itself at the beginning of the allocated
|
||||
// space.
|
||||
int size = sizeof(DynamicMessage);
|
||||
size = AlignOffset(size);
|
||||
|
||||
// Next the has_bits, which is an array of uint32s.
|
||||
type_info->has_bits_offset = size;
|
||||
int has_bits_array_size =
|
||||
DivideRoundingUp(type->field_count(), bitsizeof(uint32));
|
||||
size += has_bits_array_size * sizeof(uint32);
|
||||
size = AlignOffset(size);
|
||||
|
||||
// The ExtensionSet, if any.
|
||||
if (type->extension_range_count() > 0) {
|
||||
type_info->extensions_offset = size;
|
||||
size += sizeof(ExtensionSet);
|
||||
size = AlignOffset(size);
|
||||
} else {
|
||||
// No extensions.
|
||||
type_info->extensions_offset = -1;
|
||||
}
|
||||
|
||||
// All the fields.
|
||||
for (int i = 0; i < type->field_count(); i++) {
|
||||
// Make sure field is aligned to avoid bus errors.
|
||||
int field_size = FieldSpaceUsed(type->field(i));
|
||||
size = AlignTo(size, min(kSafeAlignment, field_size));
|
||||
offsets[i] = size;
|
||||
size += field_size;
|
||||
}
|
||||
|
||||
// Add the UnknownFieldSet to the end.
|
||||
size = AlignOffset(size);
|
||||
type_info->unknown_fields_offset = size;
|
||||
size += sizeof(UnknownFieldSet);
|
||||
|
||||
// Align the final size to make sure no clever allocators think that
|
||||
// alignment is not necessary.
|
||||
size = AlignOffset(size);
|
||||
type_info->size = size;
|
||||
|
||||
// Allocate the prototype.
|
||||
void* base = operator new(size);
|
||||
memset(base, 0, size);
|
||||
DynamicMessage* prototype = new(base) DynamicMessage(type_info);
|
||||
type_info->prototype.reset(prototype);
|
||||
|
||||
// Construct the reflection object.
|
||||
type_info->reflection.reset(
|
||||
new GeneratedMessageReflection(
|
||||
type_info->type,
|
||||
type_info->prototype.get(),
|
||||
type_info->offsets.get(),
|
||||
type_info->has_bits_offset,
|
||||
type_info->unknown_fields_offset,
|
||||
type_info->extensions_offset,
|
||||
type_info->pool,
|
||||
this,
|
||||
type_info->size));
|
||||
|
||||
// Cross link prototypes.
|
||||
prototype->CrossLinkPrototypes();
|
||||
|
||||
return prototype;
|
||||
}
|
||||
|
||||
} // namespace protobuf
|
||||
} // namespace google
|
||||
File diff suppressed because it is too large
Load Diff
@ -1,904 +0,0 @@
|
||||
// Protocol Buffers - Google's data interchange format
|
||||
// Copyright 2008 Google Inc. All rights reserved.
|
||||
// http://code.google.com/p/protobuf/
|
||||
//
|
||||
// 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.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// 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.
|
||||
|
||||
// Author: kenton@google.com (Kenton Varda)
|
||||
// Based on original Protocol Buffers design by
|
||||
// Sanjay Ghemawat, Jeff Dean, and others.
|
||||
//
|
||||
// This header is logically internal, but is made public because it is used
|
||||
// from protocol-compiler-generated code, which may reside in other components.
|
||||
|
||||
#ifndef GOOGLE_PROTOBUF_EXTENSION_SET_H__
|
||||
#define GOOGLE_PROTOBUF_EXTENSION_SET_H__
|
||||
|
||||
#include <vector>
|
||||
#include <map>
|
||||
#include <utility>
|
||||
#include <string>
|
||||
|
||||
|
||||
#include <google/protobuf/stubs/common.h>
|
||||
|
||||
namespace google {
|
||||
|
||||
namespace protobuf {
|
||||
class Descriptor; // descriptor.h
|
||||
class FieldDescriptor; // descriptor.h
|
||||
class DescriptorPool; // descriptor.h
|
||||
class MessageLite; // message_lite.h
|
||||
class Message; // message.h
|
||||
class MessageFactory; // message.h
|
||||
class UnknownFieldSet; // unknown_field_set.h
|
||||
namespace io {
|
||||
class CodedInputStream; // coded_stream.h
|
||||
class CodedOutputStream; // coded_stream.h
|
||||
}
|
||||
namespace internal {
|
||||
class FieldSkipper; // wire_format_lite.h
|
||||
class RepeatedPtrFieldBase; // repeated_field.h
|
||||
}
|
||||
template <typename Element> class RepeatedField; // repeated_field.h
|
||||
template <typename Element> class RepeatedPtrField; // repeated_field.h
|
||||
}
|
||||
|
||||
namespace protobuf {
|
||||
namespace internal {
|
||||
|
||||
// Used to store values of type WireFormatLite::FieldType without having to
|
||||
// #include wire_format_lite.h. Also, ensures that we use only one byte to
|
||||
// store these values, which is important to keep the layout of
|
||||
// ExtensionSet::Extension small.
|
||||
typedef uint8 FieldType;
|
||||
|
||||
// A function which, given an integer value, returns true if the number
|
||||
// matches one of the defined values for the corresponding enum type. This
|
||||
// is used with RegisterEnumExtension, below.
|
||||
typedef bool EnumValidityFunc(int number);
|
||||
|
||||
// Version of the above which takes an argument. This is needed to deal with
|
||||
// extensions that are not compiled in.
|
||||
typedef bool EnumValidityFuncWithArg(const void* arg, int number);
|
||||
|
||||
// Information about a registered extension.
|
||||
struct ExtensionInfo {
|
||||
inline ExtensionInfo() {}
|
||||
inline ExtensionInfo(FieldType type, bool is_repeated, bool is_packed)
|
||||
: type(type), is_repeated(is_repeated), is_packed(is_packed),
|
||||
descriptor(NULL) {}
|
||||
|
||||
FieldType type;
|
||||
bool is_repeated;
|
||||
bool is_packed;
|
||||
|
||||
struct EnumValidityCheck {
|
||||
EnumValidityFuncWithArg* func;
|
||||
const void* arg;
|
||||
};
|
||||
|
||||
union {
|
||||
EnumValidityCheck enum_validity_check;
|
||||
const MessageLite* message_prototype;
|
||||
};
|
||||
|
||||
// The descriptor for this extension, if one exists and is known. May be
|
||||
// NULL. Must not be NULL if the descriptor for the extension does not
|
||||
// live in the same pool as the descriptor for the containing type.
|
||||
const FieldDescriptor* descriptor;
|
||||
};
|
||||
|
||||
// Abstract interface for an object which looks up extension definitions. Used
|
||||
// when parsing.
|
||||
class LIBPROTOBUF_EXPORT ExtensionFinder {
|
||||
public:
|
||||
virtual ~ExtensionFinder();
|
||||
|
||||
// Find the extension with the given containing type and number.
|
||||
virtual bool Find(int number, ExtensionInfo* output) = 0;
|
||||
};
|
||||
|
||||
// Implementation of ExtensionFinder which finds extensions defined in .proto
|
||||
// files which have been compiled into the binary.
|
||||
class LIBPROTOBUF_EXPORT GeneratedExtensionFinder : public ExtensionFinder {
|
||||
public:
|
||||
GeneratedExtensionFinder(const MessageLite* containing_type)
|
||||
: containing_type_(containing_type) {}
|
||||
virtual ~GeneratedExtensionFinder() {}
|
||||
|
||||
// Returns true and fills in *output if found, otherwise returns false.
|
||||
virtual bool Find(int number, ExtensionInfo* output);
|
||||
|
||||
private:
|
||||
const MessageLite* containing_type_;
|
||||
};
|
||||
|
||||
// Note: extension_set_heavy.cc defines DescriptorPoolExtensionFinder for
|
||||
// finding extensions from a DescriptorPool.
|
||||
|
||||
// This is an internal helper class intended for use within the protocol buffer
|
||||
// library and generated classes. Clients should not use it directly. Instead,
|
||||
// use the generated accessors such as GetExtension() of the class being
|
||||
// extended.
|
||||
//
|
||||
// This class manages extensions for a protocol message object. The
|
||||
// message's HasExtension(), GetExtension(), MutableExtension(), and
|
||||
// ClearExtension() methods are just thin wrappers around the embedded
|
||||
// ExtensionSet. When parsing, if a tag number is encountered which is
|
||||
// inside one of the message type's extension ranges, the tag is passed
|
||||
// off to the ExtensionSet for parsing. Etc.
|
||||
class LIBPROTOBUF_EXPORT ExtensionSet {
|
||||
public:
|
||||
ExtensionSet();
|
||||
~ExtensionSet();
|
||||
|
||||
// These are called at startup by protocol-compiler-generated code to
|
||||
// register known extensions. The registrations are used by ParseField()
|
||||
// to look up extensions for parsed field numbers. Note that dynamic parsing
|
||||
// does not use ParseField(); only protocol-compiler-generated parsing
|
||||
// methods do.
|
||||
static void RegisterExtension(const MessageLite* containing_type,
|
||||
int number, FieldType type,
|
||||
bool is_repeated, bool is_packed);
|
||||
static void RegisterEnumExtension(const MessageLite* containing_type,
|
||||
int number, FieldType type,
|
||||
bool is_repeated, bool is_packed,
|
||||
EnumValidityFunc* is_valid);
|
||||
static void RegisterMessageExtension(const MessageLite* containing_type,
|
||||
int number, FieldType type,
|
||||
bool is_repeated, bool is_packed,
|
||||
const MessageLite* prototype);
|
||||
|
||||
// =================================================================
|
||||
|
||||
// Add all fields which are currently present to the given vector. This
|
||||
// is useful to implement Reflection::ListFields().
|
||||
void AppendToList(const Descriptor* containing_type,
|
||||
const DescriptorPool* pool,
|
||||
vector<const FieldDescriptor*>* output) const;
|
||||
|
||||
// =================================================================
|
||||
// Accessors
|
||||
//
|
||||
// Generated message classes include type-safe templated wrappers around
|
||||
// these methods. Generally you should use those rather than call these
|
||||
// directly, unless you are doing low-level memory management.
|
||||
//
|
||||
// When calling any of these accessors, the extension number requested
|
||||
// MUST exist in the DescriptorPool provided to the constructor. Otheriwse,
|
||||
// the method will fail an assert. Normally, though, you would not call
|
||||
// these directly; you would either call the generated accessors of your
|
||||
// message class (e.g. GetExtension()) or you would call the accessors
|
||||
// of the reflection interface. In both cases, it is impossible to
|
||||
// trigger this assert failure: the generated accessors only accept
|
||||
// linked-in extension types as parameters, while the Reflection interface
|
||||
// requires you to provide the FieldDescriptor describing the extension.
|
||||
//
|
||||
// When calling any of these accessors, a protocol-compiler-generated
|
||||
// implementation of the extension corresponding to the number MUST
|
||||
// be linked in, and the FieldDescriptor used to refer to it MUST be
|
||||
// the one generated by that linked-in code. Otherwise, the method will
|
||||
// die on an assert failure. The message objects returned by the message
|
||||
// accessors are guaranteed to be of the correct linked-in type.
|
||||
//
|
||||
// These methods pretty much match Reflection except that:
|
||||
// - They're not virtual.
|
||||
// - They identify fields by number rather than FieldDescriptors.
|
||||
// - They identify enum values using integers rather than descriptors.
|
||||
// - Strings provide Mutable() in addition to Set() accessors.
|
||||
|
||||
bool Has(int number) const;
|
||||
int ExtensionSize(int number) const; // Size of a repeated extension.
|
||||
FieldType ExtensionType(int number) const;
|
||||
void ClearExtension(int number);
|
||||
|
||||
// singular fields -------------------------------------------------
|
||||
|
||||
int32 GetInt32 (int number, int32 default_value) const;
|
||||
int64 GetInt64 (int number, int64 default_value) const;
|
||||
uint32 GetUInt32(int number, uint32 default_value) const;
|
||||
uint64 GetUInt64(int number, uint64 default_value) const;
|
||||
float GetFloat (int number, float default_value) const;
|
||||
double GetDouble(int number, double default_value) const;
|
||||
bool GetBool (int number, bool default_value) const;
|
||||
int GetEnum (int number, int default_value) const;
|
||||
const string & GetString (int number, const string& default_value) const;
|
||||
const MessageLite& GetMessage(int number,
|
||||
const MessageLite& default_value) const;
|
||||
const MessageLite& GetMessage(int number, const Descriptor* message_type,
|
||||
MessageFactory* factory) const;
|
||||
|
||||
// |descriptor| may be NULL so long as it is known that the descriptor for
|
||||
// the extension lives in the same pool as the descriptor for the containing
|
||||
// type.
|
||||
#define desc const FieldDescriptor* descriptor // avoid line wrapping
|
||||
void SetInt32 (int number, FieldType type, int32 value, desc);
|
||||
void SetInt64 (int number, FieldType type, int64 value, desc);
|
||||
void SetUInt32(int number, FieldType type, uint32 value, desc);
|
||||
void SetUInt64(int number, FieldType type, uint64 value, desc);
|
||||
void SetFloat (int number, FieldType type, float value, desc);
|
||||
void SetDouble(int number, FieldType type, double value, desc);
|
||||
void SetBool (int number, FieldType type, bool value, desc);
|
||||
void SetEnum (int number, FieldType type, int value, desc);
|
||||
void SetString(int number, FieldType type, const string& value, desc);
|
||||
string * MutableString (int number, FieldType type, desc);
|
||||
MessageLite* MutableMessage(int number, FieldType type,
|
||||
const MessageLite& prototype, desc);
|
||||
MessageLite* MutableMessage(const FieldDescriptor* decsriptor,
|
||||
MessageFactory* factory);
|
||||
#undef desc
|
||||
|
||||
// repeated fields -------------------------------------------------
|
||||
|
||||
int32 GetRepeatedInt32 (int number, int index) const;
|
||||
int64 GetRepeatedInt64 (int number, int index) const;
|
||||
uint32 GetRepeatedUInt32(int number, int index) const;
|
||||
uint64 GetRepeatedUInt64(int number, int index) const;
|
||||
float GetRepeatedFloat (int number, int index) const;
|
||||
double GetRepeatedDouble(int number, int index) const;
|
||||
bool GetRepeatedBool (int number, int index) const;
|
||||
int GetRepeatedEnum (int number, int index) const;
|
||||
const string & GetRepeatedString (int number, int index) const;
|
||||
const MessageLite& GetRepeatedMessage(int number, int index) const;
|
||||
|
||||
void SetRepeatedInt32 (int number, int index, int32 value);
|
||||
void SetRepeatedInt64 (int number, int index, int64 value);
|
||||
void SetRepeatedUInt32(int number, int index, uint32 value);
|
||||
void SetRepeatedUInt64(int number, int index, uint64 value);
|
||||
void SetRepeatedFloat (int number, int index, float value);
|
||||
void SetRepeatedDouble(int number, int index, double value);
|
||||
void SetRepeatedBool (int number, int index, bool value);
|
||||
void SetRepeatedEnum (int number, int index, int value);
|
||||
void SetRepeatedString(int number, int index, const string& value);
|
||||
string * MutableRepeatedString (int number, int index);
|
||||
MessageLite* MutableRepeatedMessage(int number, int index);
|
||||
|
||||
#define desc const FieldDescriptor* descriptor // avoid line wrapping
|
||||
void AddInt32 (int number, FieldType type, bool packed, int32 value, desc);
|
||||
void AddInt64 (int number, FieldType type, bool packed, int64 value, desc);
|
||||
void AddUInt32(int number, FieldType type, bool packed, uint32 value, desc);
|
||||
void AddUInt64(int number, FieldType type, bool packed, uint64 value, desc);
|
||||
void AddFloat (int number, FieldType type, bool packed, float value, desc);
|
||||
void AddDouble(int number, FieldType type, bool packed, double value, desc);
|
||||
void AddBool (int number, FieldType type, bool packed, bool value, desc);
|
||||
void AddEnum (int number, FieldType type, bool packed, int value, desc);
|
||||
void AddString(int number, FieldType type, const string& value, desc);
|
||||
string * AddString (int number, FieldType type, desc);
|
||||
MessageLite* AddMessage(int number, FieldType type,
|
||||
const MessageLite& prototype, desc);
|
||||
MessageLite* AddMessage(const FieldDescriptor* descriptor,
|
||||
MessageFactory* factory);
|
||||
#undef desc
|
||||
|
||||
void RemoveLast(int number);
|
||||
void SwapElements(int number, int index1, int index2);
|
||||
|
||||
// -----------------------------------------------------------------
|
||||
// TODO(kenton): Hardcore memory management accessors
|
||||
|
||||
// =================================================================
|
||||
// convenience methods for implementing methods of Message
|
||||
//
|
||||
// These could all be implemented in terms of the other methods of this
|
||||
// class, but providing them here helps keep the generated code size down.
|
||||
|
||||
void Clear();
|
||||
void MergeFrom(const ExtensionSet& other);
|
||||
void Swap(ExtensionSet* other);
|
||||
bool IsInitialized() const;
|
||||
|
||||
// Parses a single extension from the input. The input should start out
|
||||
// positioned immediately after the tag. |containing_type| is the default
|
||||
// instance for the containing message; it is used only to look up the
|
||||
// extension by number. See RegisterExtension(), above. Unlike the other
|
||||
// methods of ExtensionSet, this only works for generated message types --
|
||||
// it looks up extensions registered using RegisterExtension().
|
||||
bool ParseField(uint32 tag, io::CodedInputStream* input,
|
||||
ExtensionFinder* extension_finder,
|
||||
FieldSkipper* field_skipper);
|
||||
|
||||
// Specific versions for lite or full messages (constructs the appropriate
|
||||
// FieldSkipper automatically).
|
||||
bool ParseField(uint32 tag, io::CodedInputStream* input,
|
||||
const MessageLite* containing_type);
|
||||
bool ParseField(uint32 tag, io::CodedInputStream* input,
|
||||
const Message* containing_type,
|
||||
UnknownFieldSet* unknown_fields);
|
||||
|
||||
// Parse an entire message in MessageSet format. Such messages have no
|
||||
// fields, only extensions.
|
||||
bool ParseMessageSet(io::CodedInputStream* input,
|
||||
ExtensionFinder* extension_finder,
|
||||
FieldSkipper* field_skipper);
|
||||
|
||||
// Specific versions for lite or full messages (constructs the appropriate
|
||||
// FieldSkipper automatically).
|
||||
bool ParseMessageSet(io::CodedInputStream* input,
|
||||
const MessageLite* containing_type);
|
||||
bool ParseMessageSet(io::CodedInputStream* input,
|
||||
const Message* containing_type,
|
||||
UnknownFieldSet* unknown_fields);
|
||||
|
||||
// Write all extension fields with field numbers in the range
|
||||
// [start_field_number, end_field_number)
|
||||
// to the output stream, using the cached sizes computed when ByteSize() was
|
||||
// last called. Note that the range bounds are inclusive-exclusive.
|
||||
void SerializeWithCachedSizes(int start_field_number,
|
||||
int end_field_number,
|
||||
io::CodedOutputStream* output) const;
|
||||
|
||||
// Same as SerializeWithCachedSizes, but without any bounds checking.
|
||||
// The caller must ensure that target has sufficient capacity for the
|
||||
// serialized extensions.
|
||||
//
|
||||
// Returns a pointer past the last written byte.
|
||||
uint8* SerializeWithCachedSizesToArray(int start_field_number,
|
||||
int end_field_number,
|
||||
uint8* target) const;
|
||||
|
||||
// Like above but serializes in MessageSet format.
|
||||
void SerializeMessageSetWithCachedSizes(io::CodedOutputStream* output) const;
|
||||
uint8* SerializeMessageSetWithCachedSizesToArray(uint8* target) const;
|
||||
|
||||
// Returns the total serialized size of all the extensions.
|
||||
int ByteSize() const;
|
||||
|
||||
// Like ByteSize() but uses MessageSet format.
|
||||
int MessageSetByteSize() const;
|
||||
|
||||
// Returns (an estimate of) the total number of bytes used for storing the
|
||||
// extensions in memory, excluding sizeof(*this). If the ExtensionSet is
|
||||
// for a lite message (and thus possibly contains lite messages), the results
|
||||
// are undefined (might work, might crash, might corrupt data, might not even
|
||||
// be linked in). It's up to the protocol compiler to avoid calling this on
|
||||
// such ExtensionSets (easy enough since lite messages don't implement
|
||||
// SpaceUsed()).
|
||||
int SpaceUsedExcludingSelf() const;
|
||||
|
||||
private:
|
||||
|
||||
struct Extension {
|
||||
union {
|
||||
int32 int32_value;
|
||||
int64 int64_value;
|
||||
uint32 uint32_value;
|
||||
uint64 uint64_value;
|
||||
float float_value;
|
||||
double double_value;
|
||||
bool bool_value;
|
||||
int enum_value;
|
||||
string* string_value;
|
||||
MessageLite* message_value;
|
||||
|
||||
RepeatedField <int32 >* repeated_int32_value;
|
||||
RepeatedField <int64 >* repeated_int64_value;
|
||||
RepeatedField <uint32 >* repeated_uint32_value;
|
||||
RepeatedField <uint64 >* repeated_uint64_value;
|
||||
RepeatedField <float >* repeated_float_value;
|
||||
RepeatedField <double >* repeated_double_value;
|
||||
RepeatedField <bool >* repeated_bool_value;
|
||||
RepeatedField <int >* repeated_enum_value;
|
||||
RepeatedPtrField<string >* repeated_string_value;
|
||||
RepeatedPtrField<MessageLite>* repeated_message_value;
|
||||
};
|
||||
|
||||
FieldType type;
|
||||
bool is_repeated;
|
||||
|
||||
// For singular types, indicates if the extension is "cleared". This
|
||||
// happens when an extension is set and then later cleared by the caller.
|
||||
// We want to keep the Extension object around for reuse, so instead of
|
||||
// removing it from the map, we just set is_cleared = true. This has no
|
||||
// meaning for repeated types; for those, the size of the RepeatedField
|
||||
// simply becomes zero when cleared.
|
||||
bool is_cleared;
|
||||
|
||||
// For repeated types, this indicates if the [packed=true] option is set.
|
||||
bool is_packed;
|
||||
|
||||
// The descriptor for this extension, if one exists and is known. May be
|
||||
// NULL. Must not be NULL if the descriptor for the extension does not
|
||||
// live in the same pool as the descriptor for the containing type.
|
||||
const FieldDescriptor* descriptor;
|
||||
|
||||
// For packed fields, the size of the packed data is recorded here when
|
||||
// ByteSize() is called then used during serialization.
|
||||
// TODO(kenton): Use atomic<int> when C++ supports it.
|
||||
mutable int cached_size;
|
||||
|
||||
// Some helper methods for operations on a single Extension.
|
||||
void SerializeFieldWithCachedSizes(
|
||||
int number,
|
||||
io::CodedOutputStream* output) const;
|
||||
uint8* SerializeFieldWithCachedSizesToArray(
|
||||
int number,
|
||||
uint8* target) const;
|
||||
void SerializeMessageSetItemWithCachedSizes(
|
||||
int number,
|
||||
io::CodedOutputStream* output) const;
|
||||
uint8* SerializeMessageSetItemWithCachedSizesToArray(
|
||||
int number,
|
||||
uint8* target) const;
|
||||
int ByteSize(int number) const;
|
||||
int MessageSetItemByteSize(int number) const;
|
||||
void Clear();
|
||||
int GetSize() const;
|
||||
void Free();
|
||||
int SpaceUsedExcludingSelf() const;
|
||||
};
|
||||
|
||||
|
||||
// Gets the extension with the given number, creating it if it does not
|
||||
// already exist. Returns true if the extension did not already exist.
|
||||
bool MaybeNewExtension(int number, const FieldDescriptor* descriptor,
|
||||
Extension** result);
|
||||
|
||||
// Parse a single MessageSet item -- called just after the item group start
|
||||
// tag has been read.
|
||||
bool ParseMessageSetItem(io::CodedInputStream* input,
|
||||
ExtensionFinder* extension_finder,
|
||||
FieldSkipper* field_skipper);
|
||||
|
||||
|
||||
// Hack: RepeatedPtrFieldBase declares ExtensionSet as a friend. This
|
||||
// friendship should automatically extend to ExtensionSet::Extension, but
|
||||
// unfortunately some older compilers (e.g. GCC 3.4.4) do not implement this
|
||||
// correctly. So, we must provide helpers for calling methods of that
|
||||
// class.
|
||||
|
||||
// Defined in extension_set_heavy.cc.
|
||||
static inline int RepeatedMessage_SpaceUsedExcludingSelf(
|
||||
RepeatedPtrFieldBase* field);
|
||||
|
||||
// The Extension struct is small enough to be passed by value, so we use it
|
||||
// directly as the value type in the map rather than use pointers. We use
|
||||
// a map rather than hash_map here because we expect most ExtensionSets will
|
||||
// only contain a small number of extensions whereas hash_map is optimized
|
||||
// for 100 elements or more. Also, we want AppendToList() to order fields
|
||||
// by field number.
|
||||
map<int, Extension> extensions_;
|
||||
|
||||
GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(ExtensionSet);
|
||||
};
|
||||
|
||||
// These are just for convenience...
|
||||
inline void ExtensionSet::SetString(int number, FieldType type,
|
||||
const string& value,
|
||||
const FieldDescriptor* descriptor) {
|
||||
MutableString(number, type, descriptor)->assign(value);
|
||||
}
|
||||
inline void ExtensionSet::SetRepeatedString(int number, int index,
|
||||
const string& value) {
|
||||
MutableRepeatedString(number, index)->assign(value);
|
||||
}
|
||||
inline void ExtensionSet::AddString(int number, FieldType type,
|
||||
const string& value,
|
||||
const FieldDescriptor* descriptor) {
|
||||
AddString(number, type, descriptor)->assign(value);
|
||||
}
|
||||
|
||||
// ===================================================================
|
||||
// Glue for generated extension accessors
|
||||
|
||||
// -------------------------------------------------------------------
|
||||
// Template magic
|
||||
|
||||
// First we have a set of classes representing "type traits" for different
|
||||
// field types. A type traits class knows how to implement basic accessors
|
||||
// for extensions of a particular type given an ExtensionSet. The signature
|
||||
// for a type traits class looks like this:
|
||||
//
|
||||
// class TypeTraits {
|
||||
// public:
|
||||
// typedef ? ConstType;
|
||||
// typedef ? MutableType;
|
||||
//
|
||||
// static inline ConstType Get(int number, const ExtensionSet& set);
|
||||
// static inline void Set(int number, ConstType value, ExtensionSet* set);
|
||||
// static inline MutableType Mutable(int number, ExtensionSet* set);
|
||||
//
|
||||
// // Variants for repeated fields.
|
||||
// static inline ConstType Get(int number, const ExtensionSet& set,
|
||||
// int index);
|
||||
// static inline void Set(int number, int index,
|
||||
// ConstType value, ExtensionSet* set);
|
||||
// static inline MutableType Mutable(int number, int index,
|
||||
// ExtensionSet* set);
|
||||
// static inline void Add(int number, ConstType value, ExtensionSet* set);
|
||||
// static inline MutableType Add(int number, ExtensionSet* set);
|
||||
// };
|
||||
//
|
||||
// Not all of these methods make sense for all field types. For example, the
|
||||
// "Mutable" methods only make sense for strings and messages, and the
|
||||
// repeated methods only make sense for repeated types. So, each type
|
||||
// traits class implements only the set of methods from this signature that it
|
||||
// actually supports. This will cause a compiler error if the user tries to
|
||||
// access an extension using a method that doesn't make sense for its type.
|
||||
// For example, if "foo" is an extension of type "optional int32", then if you
|
||||
// try to write code like:
|
||||
// my_message.MutableExtension(foo)
|
||||
// you will get a compile error because PrimitiveTypeTraits<int32> does not
|
||||
// have a "Mutable()" method.
|
||||
|
||||
// -------------------------------------------------------------------
|
||||
// PrimitiveTypeTraits
|
||||
|
||||
// Since the ExtensionSet has different methods for each primitive type,
|
||||
// we must explicitly define the methods of the type traits class for each
|
||||
// known type.
|
||||
template <typename Type>
|
||||
class PrimitiveTypeTraits {
|
||||
public:
|
||||
typedef Type ConstType;
|
||||
|
||||
static inline ConstType Get(int number, const ExtensionSet& set,
|
||||
ConstType default_value);
|
||||
static inline void Set(int number, FieldType field_type,
|
||||
ConstType value, ExtensionSet* set);
|
||||
};
|
||||
|
||||
template <typename Type>
|
||||
class RepeatedPrimitiveTypeTraits {
|
||||
public:
|
||||
typedef Type ConstType;
|
||||
|
||||
static inline Type Get(int number, const ExtensionSet& set, int index);
|
||||
static inline void Set(int number, int index, Type value, ExtensionSet* set);
|
||||
static inline void Add(int number, FieldType field_type,
|
||||
bool is_packed, Type value, ExtensionSet* set);
|
||||
};
|
||||
|
||||
#define PROTOBUF_DEFINE_PRIMITIVE_TYPE(TYPE, METHOD) \
|
||||
template<> inline TYPE PrimitiveTypeTraits<TYPE>::Get( \
|
||||
int number, const ExtensionSet& set, TYPE default_value) { \
|
||||
return set.Get##METHOD(number, default_value); \
|
||||
} \
|
||||
template<> inline void PrimitiveTypeTraits<TYPE>::Set( \
|
||||
int number, FieldType field_type, TYPE value, ExtensionSet* set) { \
|
||||
set->Set##METHOD(number, field_type, value, NULL); \
|
||||
} \
|
||||
\
|
||||
template<> inline TYPE RepeatedPrimitiveTypeTraits<TYPE>::Get( \
|
||||
int number, const ExtensionSet& set, int index) { \
|
||||
return set.GetRepeated##METHOD(number, index); \
|
||||
} \
|
||||
template<> inline void RepeatedPrimitiveTypeTraits<TYPE>::Set( \
|
||||
int number, int index, TYPE value, ExtensionSet* set) { \
|
||||
set->SetRepeated##METHOD(number, index, value); \
|
||||
} \
|
||||
template<> inline void RepeatedPrimitiveTypeTraits<TYPE>::Add( \
|
||||
int number, FieldType field_type, bool is_packed, \
|
||||
TYPE value, ExtensionSet* set) { \
|
||||
set->Add##METHOD(number, field_type, is_packed, value, NULL); \
|
||||
}
|
||||
|
||||
PROTOBUF_DEFINE_PRIMITIVE_TYPE( int32, Int32)
|
||||
PROTOBUF_DEFINE_PRIMITIVE_TYPE( int64, Int64)
|
||||
PROTOBUF_DEFINE_PRIMITIVE_TYPE(uint32, UInt32)
|
||||
PROTOBUF_DEFINE_PRIMITIVE_TYPE(uint64, UInt64)
|
||||
PROTOBUF_DEFINE_PRIMITIVE_TYPE( float, Float)
|
||||
PROTOBUF_DEFINE_PRIMITIVE_TYPE(double, Double)
|
||||
PROTOBUF_DEFINE_PRIMITIVE_TYPE( bool, Bool)
|
||||
|
||||
#undef PROTOBUF_DEFINE_PRIMITIVE_TYPE
|
||||
|
||||
// -------------------------------------------------------------------
|
||||
// StringTypeTraits
|
||||
|
||||
// Strings support both Set() and Mutable().
|
||||
class LIBPROTOBUF_EXPORT StringTypeTraits {
|
||||
public:
|
||||
typedef const string& ConstType;
|
||||
typedef string* MutableType;
|
||||
|
||||
static inline const string& Get(int number, const ExtensionSet& set,
|
||||
ConstType default_value) {
|
||||
return set.GetString(number, default_value);
|
||||
}
|
||||
static inline void Set(int number, FieldType field_type,
|
||||
const string& value, ExtensionSet* set) {
|
||||
set->SetString(number, field_type, value, NULL);
|
||||
}
|
||||
static inline string* Mutable(int number, FieldType field_type,
|
||||
ExtensionSet* set) {
|
||||
return set->MutableString(number, field_type, NULL);
|
||||
}
|
||||
};
|
||||
|
||||
class LIBPROTOBUF_EXPORT RepeatedStringTypeTraits {
|
||||
public:
|
||||
typedef const string& ConstType;
|
||||
typedef string* MutableType;
|
||||
|
||||
static inline const string& Get(int number, const ExtensionSet& set,
|
||||
int index) {
|
||||
return set.GetRepeatedString(number, index);
|
||||
}
|
||||
static inline void Set(int number, int index,
|
||||
const string& value, ExtensionSet* set) {
|
||||
set->SetRepeatedString(number, index, value);
|
||||
}
|
||||
static inline string* Mutable(int number, int index, ExtensionSet* set) {
|
||||
return set->MutableRepeatedString(number, index);
|
||||
}
|
||||
static inline void Add(int number, FieldType field_type,
|
||||
bool /*is_packed*/, const string& value,
|
||||
ExtensionSet* set) {
|
||||
set->AddString(number, field_type, value, NULL);
|
||||
}
|
||||
static inline string* Add(int number, FieldType field_type,
|
||||
ExtensionSet* set) {
|
||||
return set->AddString(number, field_type, NULL);
|
||||
}
|
||||
};
|
||||
|
||||
// -------------------------------------------------------------------
|
||||
// EnumTypeTraits
|
||||
|
||||
// ExtensionSet represents enums using integers internally, so we have to
|
||||
// static_cast around.
|
||||
template <typename Type, bool IsValid(int)>
|
||||
class EnumTypeTraits {
|
||||
public:
|
||||
typedef Type ConstType;
|
||||
|
||||
static inline ConstType Get(int number, const ExtensionSet& set,
|
||||
ConstType default_value) {
|
||||
return static_cast<Type>(set.GetEnum(number, default_value));
|
||||
}
|
||||
static inline void Set(int number, FieldType field_type,
|
||||
ConstType value, ExtensionSet* set) {
|
||||
GOOGLE_DCHECK(IsValid(value));
|
||||
set->SetEnum(number, field_type, value, NULL);
|
||||
}
|
||||
};
|
||||
|
||||
template <typename Type, bool IsValid(int)>
|
||||
class RepeatedEnumTypeTraits {
|
||||
public:
|
||||
typedef Type ConstType;
|
||||
|
||||
static inline ConstType Get(int number, const ExtensionSet& set, int index) {
|
||||
return static_cast<Type>(set.GetRepeatedEnum(number, index));
|
||||
}
|
||||
static inline void Set(int number, int index,
|
||||
ConstType value, ExtensionSet* set) {
|
||||
GOOGLE_DCHECK(IsValid(value));
|
||||
set->SetRepeatedEnum(number, index, value);
|
||||
}
|
||||
static inline void Add(int number, FieldType field_type,
|
||||
bool is_packed, ConstType value, ExtensionSet* set) {
|
||||
GOOGLE_DCHECK(IsValid(value));
|
||||
set->AddEnum(number, field_type, is_packed, value, NULL);
|
||||
}
|
||||
};
|
||||
|
||||
// -------------------------------------------------------------------
|
||||
// MessageTypeTraits
|
||||
|
||||
// ExtensionSet guarantees that when manipulating extensions with message
|
||||
// types, the implementation used will be the compiled-in class representing
|
||||
// that type. So, we can static_cast down to the exact type we expect.
|
||||
template <typename Type>
|
||||
class MessageTypeTraits {
|
||||
public:
|
||||
typedef const Type& ConstType;
|
||||
typedef Type* MutableType;
|
||||
|
||||
static inline ConstType Get(int number, const ExtensionSet& set,
|
||||
ConstType default_value) {
|
||||
return static_cast<const Type&>(
|
||||
set.GetMessage(number, default_value));
|
||||
}
|
||||
static inline MutableType Mutable(int number, FieldType field_type,
|
||||
ExtensionSet* set) {
|
||||
return static_cast<Type*>(
|
||||
set->MutableMessage(number, field_type, Type::default_instance(), NULL));
|
||||
}
|
||||
};
|
||||
|
||||
template <typename Type>
|
||||
class RepeatedMessageTypeTraits {
|
||||
public:
|
||||
typedef const Type& ConstType;
|
||||
typedef Type* MutableType;
|
||||
|
||||
static inline ConstType Get(int number, const ExtensionSet& set, int index) {
|
||||
return static_cast<const Type&>(set.GetRepeatedMessage(number, index));
|
||||
}
|
||||
static inline MutableType Mutable(int number, int index, ExtensionSet* set) {
|
||||
return static_cast<Type*>(set->MutableRepeatedMessage(number, index));
|
||||
}
|
||||
static inline MutableType Add(int number, FieldType field_type,
|
||||
ExtensionSet* set) {
|
||||
return static_cast<Type*>(
|
||||
set->AddMessage(number, field_type, Type::default_instance(), NULL));
|
||||
}
|
||||
};
|
||||
|
||||
// -------------------------------------------------------------------
|
||||
// ExtensionIdentifier
|
||||
|
||||
// This is the type of actual extension objects. E.g. if you have:
|
||||
// extends Foo with optional int32 bar = 1234;
|
||||
// then "bar" will be defined in C++ as:
|
||||
// ExtensionIdentifier<Foo, PrimitiveTypeTraits<int32>, 1, false> bar(1234);
|
||||
//
|
||||
// Note that we could, in theory, supply the field number as a template
|
||||
// parameter, and thus make an instance of ExtensionIdentifier have no
|
||||
// actual contents. However, if we did that, then using at extension
|
||||
// identifier would not necessarily cause the compiler to output any sort
|
||||
// of reference to any simple defined in the extension's .pb.o file. Some
|
||||
// linkers will actually drop object files that are not explicitly referenced,
|
||||
// but that would be bad because it would cause this extension to not be
|
||||
// registered at static initialization, and therefore using it would crash.
|
||||
|
||||
template <typename ExtendeeType, typename TypeTraitsType,
|
||||
FieldType field_type, bool is_packed>
|
||||
class ExtensionIdentifier {
|
||||
public:
|
||||
typedef TypeTraitsType TypeTraits;
|
||||
typedef ExtendeeType Extendee;
|
||||
|
||||
ExtensionIdentifier(int number, typename TypeTraits::ConstType default_value)
|
||||
: number_(number), default_value_(default_value) {}
|
||||
inline int number() const { return number_; }
|
||||
typename TypeTraits::ConstType default_value() const {
|
||||
return default_value_;
|
||||
}
|
||||
|
||||
private:
|
||||
const int number_;
|
||||
typename TypeTraits::ConstType default_value_;
|
||||
};
|
||||
|
||||
// -------------------------------------------------------------------
|
||||
// Generated accessors
|
||||
|
||||
// This macro should be expanded in the context of a generated type which
|
||||
// has extensions.
|
||||
//
|
||||
// We use "_proto_TypeTraits" as a type name below because "TypeTraits"
|
||||
// causes problems if the class has a nested message or enum type with that
|
||||
// name and "_TypeTraits" is technically reserved for the C++ library since
|
||||
// it starts with an underscore followed by a capital letter.
|
||||
#define GOOGLE_PROTOBUF_EXTENSION_ACCESSORS(CLASSNAME) \
|
||||
/* Has, Size, Clear */ \
|
||||
template <typename _proto_TypeTraits, \
|
||||
::google::protobuf::internal::FieldType field_type, \
|
||||
bool is_packed> \
|
||||
inline bool HasExtension( \
|
||||
const ::google::protobuf::internal::ExtensionIdentifier< \
|
||||
CLASSNAME, _proto_TypeTraits, field_type, is_packed>& id) const { \
|
||||
return _extensions_.Has(id.number()); \
|
||||
} \
|
||||
\
|
||||
template <typename _proto_TypeTraits, \
|
||||
::google::protobuf::internal::FieldType field_type, \
|
||||
bool is_packed> \
|
||||
inline void ClearExtension( \
|
||||
const ::google::protobuf::internal::ExtensionIdentifier< \
|
||||
CLASSNAME, _proto_TypeTraits, field_type, is_packed>& id) { \
|
||||
_extensions_.ClearExtension(id.number()); \
|
||||
} \
|
||||
\
|
||||
template <typename _proto_TypeTraits, \
|
||||
::google::protobuf::internal::FieldType field_type, \
|
||||
bool is_packed> \
|
||||
inline int ExtensionSize( \
|
||||
const ::google::protobuf::internal::ExtensionIdentifier< \
|
||||
CLASSNAME, _proto_TypeTraits, field_type, is_packed>& id) const { \
|
||||
return _extensions_.ExtensionSize(id.number()); \
|
||||
} \
|
||||
\
|
||||
/* Singular accessors */ \
|
||||
template <typename _proto_TypeTraits, \
|
||||
::google::protobuf::internal::FieldType field_type, \
|
||||
bool is_packed> \
|
||||
inline typename _proto_TypeTraits::ConstType GetExtension( \
|
||||
const ::google::protobuf::internal::ExtensionIdentifier< \
|
||||
CLASSNAME, _proto_TypeTraits, field_type, is_packed>& id) const { \
|
||||
return _proto_TypeTraits::Get(id.number(), _extensions_, \
|
||||
id.default_value()); \
|
||||
} \
|
||||
\
|
||||
template <typename _proto_TypeTraits, \
|
||||
::google::protobuf::internal::FieldType field_type, \
|
||||
bool is_packed> \
|
||||
inline typename _proto_TypeTraits::MutableType MutableExtension( \
|
||||
const ::google::protobuf::internal::ExtensionIdentifier< \
|
||||
CLASSNAME, _proto_TypeTraits, field_type, is_packed>& id) { \
|
||||
return _proto_TypeTraits::Mutable(id.number(), field_type, &_extensions_);\
|
||||
} \
|
||||
\
|
||||
template <typename _proto_TypeTraits, \
|
||||
::google::protobuf::internal::FieldType field_type, \
|
||||
bool is_packed> \
|
||||
inline void SetExtension( \
|
||||
const ::google::protobuf::internal::ExtensionIdentifier< \
|
||||
CLASSNAME, _proto_TypeTraits, field_type, is_packed>& id, \
|
||||
typename _proto_TypeTraits::ConstType value) { \
|
||||
_proto_TypeTraits::Set(id.number(), field_type, value, &_extensions_); \
|
||||
} \
|
||||
\
|
||||
/* Repeated accessors */ \
|
||||
template <typename _proto_TypeTraits, \
|
||||
::google::protobuf::internal::FieldType field_type, \
|
||||
bool is_packed> \
|
||||
inline typename _proto_TypeTraits::ConstType GetExtension( \
|
||||
const ::google::protobuf::internal::ExtensionIdentifier< \
|
||||
CLASSNAME, _proto_TypeTraits, field_type, is_packed>& id, \
|
||||
int index) const { \
|
||||
return _proto_TypeTraits::Get(id.number(), _extensions_, index); \
|
||||
} \
|
||||
\
|
||||
template <typename _proto_TypeTraits, \
|
||||
::google::protobuf::internal::FieldType field_type, \
|
||||
bool is_packed> \
|
||||
inline typename _proto_TypeTraits::MutableType MutableExtension( \
|
||||
const ::google::protobuf::internal::ExtensionIdentifier< \
|
||||
CLASSNAME, _proto_TypeTraits, field_type, is_packed>& id, \
|
||||
int index) { \
|
||||
return _proto_TypeTraits::Mutable(id.number(), index, &_extensions_); \
|
||||
} \
|
||||
\
|
||||
template <typename _proto_TypeTraits, \
|
||||
::google::protobuf::internal::FieldType field_type, \
|
||||
bool is_packed> \
|
||||
inline void SetExtension( \
|
||||
const ::google::protobuf::internal::ExtensionIdentifier< \
|
||||
CLASSNAME, _proto_TypeTraits, field_type, is_packed>& id, \
|
||||
int index, typename _proto_TypeTraits::ConstType value) { \
|
||||
_proto_TypeTraits::Set(id.number(), index, value, &_extensions_); \
|
||||
} \
|
||||
\
|
||||
template <typename _proto_TypeTraits, \
|
||||
::google::protobuf::internal::FieldType field_type, \
|
||||
bool is_packed> \
|
||||
inline typename _proto_TypeTraits::MutableType AddExtension( \
|
||||
const ::google::protobuf::internal::ExtensionIdentifier< \
|
||||
CLASSNAME, _proto_TypeTraits, field_type, is_packed>& id) { \
|
||||
return _proto_TypeTraits::Add(id.number(), field_type, &_extensions_); \
|
||||
} \
|
||||
\
|
||||
template <typename _proto_TypeTraits, \
|
||||
::google::protobuf::internal::FieldType field_type, \
|
||||
bool is_packed> \
|
||||
inline void AddExtension( \
|
||||
const ::google::protobuf::internal::ExtensionIdentifier< \
|
||||
CLASSNAME, _proto_TypeTraits, field_type, is_packed>& id, \
|
||||
typename _proto_TypeTraits::ConstType value) { \
|
||||
_proto_TypeTraits::Add(id.number(), field_type, is_packed, \
|
||||
value, &_extensions_); \
|
||||
}
|
||||
|
||||
} // namespace internal
|
||||
} // namespace protobuf
|
||||
|
||||
} // namespace google
|
||||
#endif // GOOGLE_PROTOBUF_EXTENSION_SET_H__
|
||||
@ -1,457 +0,0 @@
|
||||
// Protocol Buffers - Google's data interchange format
|
||||
// Copyright 2008 Google Inc. All rights reserved.
|
||||
// http://code.google.com/p/protobuf/
|
||||
//
|
||||
// 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.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// 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.
|
||||
|
||||
// Author: kenton@google.com (Kenton Varda)
|
||||
// Based on original Protocol Buffers design by
|
||||
// Sanjay Ghemawat, Jeff Dean, and others.
|
||||
//
|
||||
// Contains methods defined in extension_set.h which cannot be part of the
|
||||
// lite library because they use descriptors or reflection.
|
||||
|
||||
#include <google/protobuf/extension_set.h>
|
||||
#include <google/protobuf/descriptor.h>
|
||||
#include <google/protobuf/message.h>
|
||||
#include <google/protobuf/repeated_field.h>
|
||||
#include <google/protobuf/wire_format.h>
|
||||
#include <google/protobuf/wire_format_lite_inl.h>
|
||||
|
||||
namespace google {
|
||||
namespace protobuf {
|
||||
namespace internal {
|
||||
|
||||
// Implementation of ExtensionFinder which finds extensions in a given
|
||||
// DescriptorPool, using the given MessageFactory to construct sub-objects.
|
||||
// This class is implemented in extension_set_heavy.cc.
|
||||
class DescriptorPoolExtensionFinder : public ExtensionFinder {
|
||||
public:
|
||||
DescriptorPoolExtensionFinder(const DescriptorPool* pool,
|
||||
MessageFactory* factory,
|
||||
const Descriptor* containing_type)
|
||||
: pool_(pool), factory_(factory), containing_type_(containing_type) {}
|
||||
virtual ~DescriptorPoolExtensionFinder() {}
|
||||
|
||||
virtual bool Find(int number, ExtensionInfo* output);
|
||||
|
||||
private:
|
||||
const DescriptorPool* pool_;
|
||||
MessageFactory* factory_;
|
||||
const Descriptor* containing_type_;
|
||||
};
|
||||
|
||||
void ExtensionSet::AppendToList(const Descriptor* containing_type,
|
||||
const DescriptorPool* pool,
|
||||
vector<const FieldDescriptor*>* output) const {
|
||||
for (map<int, Extension>::const_iterator iter = extensions_.begin();
|
||||
iter != extensions_.end(); ++iter) {
|
||||
bool has = false;
|
||||
if (iter->second.is_repeated) {
|
||||
has = iter->second.GetSize() > 0;
|
||||
} else {
|
||||
has = !iter->second.is_cleared;
|
||||
}
|
||||
|
||||
if (has) {
|
||||
// TODO(kenton): Looking up each field by number is somewhat unfortunate.
|
||||
// Is there a better way? The problem is that descriptors are lazily-
|
||||
// initialized, so they might not even be constructed until
|
||||
// AppendToList() is called.
|
||||
|
||||
if (iter->second.descriptor == NULL) {
|
||||
output->push_back(pool->FindExtensionByNumber(
|
||||
containing_type, iter->first));
|
||||
} else {
|
||||
output->push_back(iter->second.descriptor);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
inline FieldDescriptor::Type real_type(FieldType type) {
|
||||
GOOGLE_DCHECK(type > 0 && type <= FieldDescriptor::MAX_TYPE);
|
||||
return static_cast<FieldDescriptor::Type>(type);
|
||||
}
|
||||
|
||||
inline FieldDescriptor::CppType cpp_type(FieldType type) {
|
||||
return FieldDescriptor::TypeToCppType(
|
||||
static_cast<FieldDescriptor::Type>(type));
|
||||
}
|
||||
|
||||
#define GOOGLE_DCHECK_TYPE(EXTENSION, LABEL, CPPTYPE) \
|
||||
GOOGLE_DCHECK_EQ((EXTENSION).is_repeated ? FieldDescriptor::LABEL_REPEATED \
|
||||
: FieldDescriptor::LABEL_OPTIONAL, \
|
||||
FieldDescriptor::LABEL_##LABEL); \
|
||||
GOOGLE_DCHECK_EQ(cpp_type((EXTENSION).type), FieldDescriptor::CPPTYPE_##CPPTYPE)
|
||||
|
||||
const MessageLite& ExtensionSet::GetMessage(int number,
|
||||
const Descriptor* message_type,
|
||||
MessageFactory* factory) const {
|
||||
map<int, Extension>::const_iterator iter = extensions_.find(number);
|
||||
if (iter == extensions_.end() || iter->second.is_cleared) {
|
||||
// Not present. Return the default value.
|
||||
return *factory->GetPrototype(message_type);
|
||||
} else {
|
||||
GOOGLE_DCHECK_TYPE(iter->second, OPTIONAL, MESSAGE);
|
||||
return *iter->second.message_value;
|
||||
}
|
||||
}
|
||||
|
||||
MessageLite* ExtensionSet::MutableMessage(const FieldDescriptor* descriptor,
|
||||
MessageFactory* factory) {
|
||||
Extension* extension;
|
||||
if (MaybeNewExtension(descriptor->number(), descriptor, &extension)) {
|
||||
extension->type = descriptor->type();
|
||||
GOOGLE_DCHECK_EQ(cpp_type(extension->type), FieldDescriptor::CPPTYPE_MESSAGE);
|
||||
extension->is_repeated = false;
|
||||
extension->is_packed = false;
|
||||
const MessageLite* prototype =
|
||||
factory->GetPrototype(descriptor->message_type());
|
||||
GOOGLE_CHECK(prototype != NULL);
|
||||
extension->message_value = prototype->New();
|
||||
} else {
|
||||
GOOGLE_DCHECK_TYPE(*extension, OPTIONAL, MESSAGE);
|
||||
}
|
||||
extension->is_cleared = false;
|
||||
return extension->message_value;
|
||||
}
|
||||
|
||||
MessageLite* ExtensionSet::AddMessage(const FieldDescriptor* descriptor,
|
||||
MessageFactory* factory) {
|
||||
Extension* extension;
|
||||
if (MaybeNewExtension(descriptor->number(), descriptor, &extension)) {
|
||||
extension->type = descriptor->type();
|
||||
GOOGLE_DCHECK_EQ(cpp_type(extension->type), FieldDescriptor::CPPTYPE_MESSAGE);
|
||||
extension->is_repeated = true;
|
||||
extension->repeated_message_value =
|
||||
new RepeatedPtrField<MessageLite>();
|
||||
} else {
|
||||
GOOGLE_DCHECK_TYPE(*extension, REPEATED, MESSAGE);
|
||||
}
|
||||
|
||||
// RepeatedPtrField<Message> does not know how to Add() since it cannot
|
||||
// allocate an abstract object, so we have to be tricky.
|
||||
MessageLite* result = extension->repeated_message_value
|
||||
->AddFromCleared<internal::GenericTypeHandler<MessageLite> >();
|
||||
if (result == NULL) {
|
||||
const MessageLite* prototype;
|
||||
if (extension->repeated_message_value->size() == 0) {
|
||||
prototype = factory->GetPrototype(descriptor->message_type());
|
||||
GOOGLE_CHECK(prototype != NULL);
|
||||
} else {
|
||||
prototype = &extension->repeated_message_value->Get(0);
|
||||
}
|
||||
result = prototype->New();
|
||||
extension->repeated_message_value->AddAllocated(result);
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
static bool ValidateEnumUsingDescriptor(const void* arg, int number) {
|
||||
return reinterpret_cast<const EnumDescriptor*>(arg)
|
||||
->FindValueByNumber(number) != NULL;
|
||||
}
|
||||
|
||||
bool DescriptorPoolExtensionFinder::Find(int number, ExtensionInfo* output) {
|
||||
const FieldDescriptor* extension =
|
||||
pool_->FindExtensionByNumber(containing_type_, number);
|
||||
if (extension == NULL) {
|
||||
return false;
|
||||
} else {
|
||||
output->type = extension->type();
|
||||
output->is_repeated = extension->is_repeated();
|
||||
output->is_packed = extension->options().packed();
|
||||
output->descriptor = extension;
|
||||
if (extension->cpp_type() == FieldDescriptor::CPPTYPE_MESSAGE) {
|
||||
output->message_prototype =
|
||||
factory_->GetPrototype(extension->message_type());
|
||||
GOOGLE_CHECK(output->message_prototype != NULL)
|
||||
<< "Extension factory's GetPrototype() returned NULL for extension: "
|
||||
<< extension->full_name();
|
||||
} else if (extension->cpp_type() == FieldDescriptor::CPPTYPE_ENUM) {
|
||||
output->enum_validity_check.func = ValidateEnumUsingDescriptor;
|
||||
output->enum_validity_check.arg = extension->enum_type();
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
bool ExtensionSet::ParseField(uint32 tag, io::CodedInputStream* input,
|
||||
const Message* containing_type,
|
||||
UnknownFieldSet* unknown_fields) {
|
||||
UnknownFieldSetFieldSkipper skipper(unknown_fields);
|
||||
if (input->GetExtensionPool() == NULL) {
|
||||
GeneratedExtensionFinder finder(containing_type);
|
||||
return ParseField(tag, input, &finder, &skipper);
|
||||
} else {
|
||||
DescriptorPoolExtensionFinder finder(input->GetExtensionPool(),
|
||||
input->GetExtensionFactory(),
|
||||
containing_type->GetDescriptor());
|
||||
return ParseField(tag, input, &finder, &skipper);
|
||||
}
|
||||
}
|
||||
|
||||
bool ExtensionSet::ParseMessageSet(io::CodedInputStream* input,
|
||||
const Message* containing_type,
|
||||
UnknownFieldSet* unknown_fields) {
|
||||
UnknownFieldSetFieldSkipper skipper(unknown_fields);
|
||||
if (input->GetExtensionPool() == NULL) {
|
||||
GeneratedExtensionFinder finder(containing_type);
|
||||
return ParseMessageSet(input, &finder, &skipper);
|
||||
} else {
|
||||
DescriptorPoolExtensionFinder finder(input->GetExtensionPool(),
|
||||
input->GetExtensionFactory(),
|
||||
containing_type->GetDescriptor());
|
||||
return ParseMessageSet(input, &finder, &skipper);
|
||||
}
|
||||
}
|
||||
|
||||
int ExtensionSet::SpaceUsedExcludingSelf() const {
|
||||
int total_size =
|
||||
extensions_.size() * sizeof(map<int, Extension>::value_type);
|
||||
for (map<int, Extension>::const_iterator iter = extensions_.begin(),
|
||||
end = extensions_.end();
|
||||
iter != end;
|
||||
++iter) {
|
||||
total_size += iter->second.SpaceUsedExcludingSelf();
|
||||
}
|
||||
return total_size;
|
||||
}
|
||||
|
||||
inline int ExtensionSet::RepeatedMessage_SpaceUsedExcludingSelf(
|
||||
RepeatedPtrFieldBase* field) {
|
||||
return field->SpaceUsedExcludingSelf<GenericTypeHandler<Message> >();
|
||||
}
|
||||
|
||||
int ExtensionSet::Extension::SpaceUsedExcludingSelf() const {
|
||||
int total_size = 0;
|
||||
if (is_repeated) {
|
||||
switch (cpp_type(type)) {
|
||||
#define HANDLE_TYPE(UPPERCASE, LOWERCASE) \
|
||||
case FieldDescriptor::CPPTYPE_##UPPERCASE: \
|
||||
total_size += sizeof(*repeated_##LOWERCASE##_value) + \
|
||||
repeated_##LOWERCASE##_value->SpaceUsedExcludingSelf();\
|
||||
break
|
||||
|
||||
HANDLE_TYPE( INT32, int32);
|
||||
HANDLE_TYPE( INT64, int64);
|
||||
HANDLE_TYPE( UINT32, uint32);
|
||||
HANDLE_TYPE( UINT64, uint64);
|
||||
HANDLE_TYPE( FLOAT, float);
|
||||
HANDLE_TYPE( DOUBLE, double);
|
||||
HANDLE_TYPE( BOOL, bool);
|
||||
HANDLE_TYPE( ENUM, enum);
|
||||
HANDLE_TYPE( STRING, string);
|
||||
#undef HANDLE_TYPE
|
||||
|
||||
case FieldDescriptor::CPPTYPE_MESSAGE:
|
||||
// repeated_message_value is actually a RepeatedPtrField<MessageLite>,
|
||||
// but MessageLite has no SpaceUsed(), so we must directly call
|
||||
// RepeatedPtrFieldBase::SpaceUsedExcludingSelf() with a different type
|
||||
// handler.
|
||||
total_size += sizeof(*repeated_message_value) +
|
||||
RepeatedMessage_SpaceUsedExcludingSelf(repeated_message_value);
|
||||
break;
|
||||
}
|
||||
} else {
|
||||
switch (cpp_type(type)) {
|
||||
case FieldDescriptor::CPPTYPE_STRING:
|
||||
total_size += sizeof(*string_value) +
|
||||
StringSpaceUsedExcludingSelf(*string_value);
|
||||
break;
|
||||
case FieldDescriptor::CPPTYPE_MESSAGE:
|
||||
total_size += down_cast<Message*>(message_value)->SpaceUsed();
|
||||
break;
|
||||
default:
|
||||
// No extra storage costs for primitive types.
|
||||
break;
|
||||
}
|
||||
}
|
||||
return total_size;
|
||||
}
|
||||
|
||||
// The Serialize*ToArray methods are only needed in the heavy library, as
|
||||
// the lite library only generates SerializeWithCachedSizes.
|
||||
uint8* ExtensionSet::SerializeWithCachedSizesToArray(
|
||||
int start_field_number, int end_field_number,
|
||||
uint8* target) const {
|
||||
map<int, Extension>::const_iterator iter;
|
||||
for (iter = extensions_.lower_bound(start_field_number);
|
||||
iter != extensions_.end() && iter->first < end_field_number;
|
||||
++iter) {
|
||||
target = iter->second.SerializeFieldWithCachedSizesToArray(iter->first,
|
||||
target);
|
||||
}
|
||||
return target;
|
||||
}
|
||||
|
||||
uint8* ExtensionSet::SerializeMessageSetWithCachedSizesToArray(
|
||||
uint8* target) const {
|
||||
map<int, Extension>::const_iterator iter;
|
||||
for (iter = extensions_.begin(); iter != extensions_.end(); ++iter) {
|
||||
target = iter->second.SerializeMessageSetItemWithCachedSizesToArray(
|
||||
iter->first, target);
|
||||
}
|
||||
return target;
|
||||
}
|
||||
|
||||
uint8* ExtensionSet::Extension::SerializeFieldWithCachedSizesToArray(
|
||||
int number, uint8* target) const {
|
||||
if (is_repeated) {
|
||||
if (is_packed) {
|
||||
if (cached_size == 0) return target;
|
||||
|
||||
target = WireFormatLite::WriteTagToArray(number,
|
||||
WireFormatLite::WIRETYPE_LENGTH_DELIMITED, target);
|
||||
target = WireFormatLite::WriteInt32NoTagToArray(cached_size, target);
|
||||
|
||||
switch (real_type(type)) {
|
||||
#define HANDLE_TYPE(UPPERCASE, CAMELCASE, LOWERCASE) \
|
||||
case FieldDescriptor::TYPE_##UPPERCASE: \
|
||||
for (int i = 0; i < repeated_##LOWERCASE##_value->size(); i++) { \
|
||||
target = WireFormatLite::Write##CAMELCASE##NoTagToArray( \
|
||||
repeated_##LOWERCASE##_value->Get(i), target); \
|
||||
} \
|
||||
break
|
||||
|
||||
HANDLE_TYPE( INT32, Int32, int32);
|
||||
HANDLE_TYPE( INT64, Int64, int64);
|
||||
HANDLE_TYPE( UINT32, UInt32, uint32);
|
||||
HANDLE_TYPE( UINT64, UInt64, uint64);
|
||||
HANDLE_TYPE( SINT32, SInt32, int32);
|
||||
HANDLE_TYPE( SINT64, SInt64, int64);
|
||||
HANDLE_TYPE( FIXED32, Fixed32, uint32);
|
||||
HANDLE_TYPE( FIXED64, Fixed64, uint64);
|
||||
HANDLE_TYPE(SFIXED32, SFixed32, int32);
|
||||
HANDLE_TYPE(SFIXED64, SFixed64, int64);
|
||||
HANDLE_TYPE( FLOAT, Float, float);
|
||||
HANDLE_TYPE( DOUBLE, Double, double);
|
||||
HANDLE_TYPE( BOOL, Bool, bool);
|
||||
HANDLE_TYPE( ENUM, Enum, enum);
|
||||
#undef HANDLE_TYPE
|
||||
|
||||
case WireFormatLite::TYPE_STRING:
|
||||
case WireFormatLite::TYPE_BYTES:
|
||||
case WireFormatLite::TYPE_GROUP:
|
||||
case WireFormatLite::TYPE_MESSAGE:
|
||||
GOOGLE_LOG(FATAL) << "Non-primitive types can't be packed.";
|
||||
break;
|
||||
}
|
||||
} else {
|
||||
switch (real_type(type)) {
|
||||
#define HANDLE_TYPE(UPPERCASE, CAMELCASE, LOWERCASE) \
|
||||
case FieldDescriptor::TYPE_##UPPERCASE: \
|
||||
for (int i = 0; i < repeated_##LOWERCASE##_value->size(); i++) { \
|
||||
target = WireFormatLite::Write##CAMELCASE##ToArray(number, \
|
||||
repeated_##LOWERCASE##_value->Get(i), target); \
|
||||
} \
|
||||
break
|
||||
|
||||
HANDLE_TYPE( INT32, Int32, int32);
|
||||
HANDLE_TYPE( INT64, Int64, int64);
|
||||
HANDLE_TYPE( UINT32, UInt32, uint32);
|
||||
HANDLE_TYPE( UINT64, UInt64, uint64);
|
||||
HANDLE_TYPE( SINT32, SInt32, int32);
|
||||
HANDLE_TYPE( SINT64, SInt64, int64);
|
||||
HANDLE_TYPE( FIXED32, Fixed32, uint32);
|
||||
HANDLE_TYPE( FIXED64, Fixed64, uint64);
|
||||
HANDLE_TYPE(SFIXED32, SFixed32, int32);
|
||||
HANDLE_TYPE(SFIXED64, SFixed64, int64);
|
||||
HANDLE_TYPE( FLOAT, Float, float);
|
||||
HANDLE_TYPE( DOUBLE, Double, double);
|
||||
HANDLE_TYPE( BOOL, Bool, bool);
|
||||
HANDLE_TYPE( STRING, String, string);
|
||||
HANDLE_TYPE( BYTES, Bytes, string);
|
||||
HANDLE_TYPE( ENUM, Enum, enum);
|
||||
HANDLE_TYPE( GROUP, Group, message);
|
||||
HANDLE_TYPE( MESSAGE, Message, message);
|
||||
#undef HANDLE_TYPE
|
||||
}
|
||||
}
|
||||
} else if (!is_cleared) {
|
||||
switch (real_type(type)) {
|
||||
#define HANDLE_TYPE(UPPERCASE, CAMELCASE, VALUE) \
|
||||
case FieldDescriptor::TYPE_##UPPERCASE: \
|
||||
target = WireFormatLite::Write##CAMELCASE##ToArray( \
|
||||
number, VALUE, target); \
|
||||
break
|
||||
|
||||
HANDLE_TYPE( INT32, Int32, int32_value);
|
||||
HANDLE_TYPE( INT64, Int64, int64_value);
|
||||
HANDLE_TYPE( UINT32, UInt32, uint32_value);
|
||||
HANDLE_TYPE( UINT64, UInt64, uint64_value);
|
||||
HANDLE_TYPE( SINT32, SInt32, int32_value);
|
||||
HANDLE_TYPE( SINT64, SInt64, int64_value);
|
||||
HANDLE_TYPE( FIXED32, Fixed32, uint32_value);
|
||||
HANDLE_TYPE( FIXED64, Fixed64, uint64_value);
|
||||
HANDLE_TYPE(SFIXED32, SFixed32, int32_value);
|
||||
HANDLE_TYPE(SFIXED64, SFixed64, int64_value);
|
||||
HANDLE_TYPE( FLOAT, Float, float_value);
|
||||
HANDLE_TYPE( DOUBLE, Double, double_value);
|
||||
HANDLE_TYPE( BOOL, Bool, bool_value);
|
||||
HANDLE_TYPE( STRING, String, *string_value);
|
||||
HANDLE_TYPE( BYTES, Bytes, *string_value);
|
||||
HANDLE_TYPE( ENUM, Enum, enum_value);
|
||||
HANDLE_TYPE( GROUP, Group, *message_value);
|
||||
HANDLE_TYPE( MESSAGE, Message, *message_value);
|
||||
#undef HANDLE_TYPE
|
||||
}
|
||||
}
|
||||
return target;
|
||||
}
|
||||
|
||||
uint8* ExtensionSet::Extension::SerializeMessageSetItemWithCachedSizesToArray(
|
||||
int number,
|
||||
uint8* target) const {
|
||||
if (type != WireFormatLite::TYPE_MESSAGE || is_repeated) {
|
||||
// Not a valid MessageSet extension, but serialize it the normal way.
|
||||
GOOGLE_LOG(WARNING) << "Invalid message set extension.";
|
||||
return SerializeFieldWithCachedSizesToArray(number, target);
|
||||
}
|
||||
|
||||
if (is_cleared) return target;
|
||||
|
||||
// Start group.
|
||||
target = io::CodedOutputStream::WriteTagToArray(
|
||||
WireFormatLite::kMessageSetItemStartTag, target);
|
||||
// Write type ID.
|
||||
target = WireFormatLite::WriteUInt32ToArray(
|
||||
WireFormatLite::kMessageSetTypeIdNumber, number, target);
|
||||
// Write message.
|
||||
target = WireFormatLite::WriteMessageToArray(
|
||||
WireFormatLite::kMessageSetMessageNumber, *message_value, target);
|
||||
// End group.
|
||||
target = io::CodedOutputStream::WriteTagToArray(
|
||||
WireFormatLite::kMessageSetItemEndTag, target);
|
||||
return target;
|
||||
}
|
||||
|
||||
} // namespace internal
|
||||
} // namespace protobuf
|
||||
} // namespace google
|
||||
@ -1,642 +0,0 @@
|
||||
// Protocol Buffers - Google's data interchange format
|
||||
// Copyright 2008 Google Inc. All rights reserved.
|
||||
// http://code.google.com/p/protobuf/
|
||||
//
|
||||
// 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.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// 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.
|
||||
|
||||
// Author: kenton@google.com (Kenton Varda)
|
||||
// Based on original Protocol Buffers design by
|
||||
// Sanjay Ghemawat, Jeff Dean, and others.
|
||||
|
||||
#include <google/protobuf/extension_set.h>
|
||||
#include <google/protobuf/unittest.pb.h>
|
||||
#include <google/protobuf/test_util.h>
|
||||
#include <google/protobuf/descriptor.pb.h>
|
||||
#include <google/protobuf/descriptor.h>
|
||||
#include <google/protobuf/dynamic_message.h>
|
||||
#include <google/protobuf/wire_format.h>
|
||||
#include <google/protobuf/io/coded_stream.h>
|
||||
#include <google/protobuf/io/zero_copy_stream_impl.h>
|
||||
|
||||
#include <google/protobuf/stubs/common.h>
|
||||
#include <google/protobuf/stubs/strutil.h>
|
||||
#include <google/protobuf/testing/googletest.h>
|
||||
#include <gtest/gtest.h>
|
||||
#include <google/protobuf/stubs/stl_util-inl.h>
|
||||
|
||||
namespace google {
|
||||
namespace protobuf {
|
||||
namespace internal {
|
||||
namespace {
|
||||
|
||||
// This test closely mirrors google/protobuf/compiler/cpp/unittest.cc
|
||||
// except that it uses extensions rather than regular fields.
|
||||
|
||||
TEST(ExtensionSetTest, Defaults) {
|
||||
// Check that all default values are set correctly in the initial message.
|
||||
unittest::TestAllExtensions message;
|
||||
|
||||
TestUtil::ExpectExtensionsClear(message);
|
||||
|
||||
// Messages should return pointers to default instances until first use.
|
||||
// (This is not checked by ExpectClear() since it is not actually true after
|
||||
// the fields have been set and then cleared.)
|
||||
EXPECT_EQ(&unittest::OptionalGroup_extension::default_instance(),
|
||||
&message.GetExtension(unittest::optionalgroup_extension));
|
||||
EXPECT_EQ(&unittest::TestAllTypes::NestedMessage::default_instance(),
|
||||
&message.GetExtension(unittest::optional_nested_message_extension));
|
||||
EXPECT_EQ(&unittest::ForeignMessage::default_instance(),
|
||||
&message.GetExtension(
|
||||
unittest::optional_foreign_message_extension));
|
||||
EXPECT_EQ(&unittest_import::ImportMessage::default_instance(),
|
||||
&message.GetExtension(unittest::optional_import_message_extension));
|
||||
}
|
||||
|
||||
TEST(ExtensionSetTest, Accessors) {
|
||||
// Set every field to a unique value then go back and check all those
|
||||
// values.
|
||||
unittest::TestAllExtensions message;
|
||||
|
||||
TestUtil::SetAllExtensions(&message);
|
||||
TestUtil::ExpectAllExtensionsSet(message);
|
||||
|
||||
TestUtil::ModifyRepeatedExtensions(&message);
|
||||
TestUtil::ExpectRepeatedExtensionsModified(message);
|
||||
}
|
||||
|
||||
TEST(ExtensionSetTest, Clear) {
|
||||
// Set every field to a unique value, clear the message, then check that
|
||||
// it is cleared.
|
||||
unittest::TestAllExtensions message;
|
||||
|
||||
TestUtil::SetAllExtensions(&message);
|
||||
message.Clear();
|
||||
TestUtil::ExpectExtensionsClear(message);
|
||||
|
||||
// Unlike with the defaults test, we do NOT expect that requesting embedded
|
||||
// messages will return a pointer to the default instance. Instead, they
|
||||
// should return the objects that were created when mutable_blah() was
|
||||
// called.
|
||||
EXPECT_NE(&unittest::OptionalGroup_extension::default_instance(),
|
||||
&message.GetExtension(unittest::optionalgroup_extension));
|
||||
EXPECT_NE(&unittest::TestAllTypes::NestedMessage::default_instance(),
|
||||
&message.GetExtension(unittest::optional_nested_message_extension));
|
||||
EXPECT_NE(&unittest::ForeignMessage::default_instance(),
|
||||
&message.GetExtension(
|
||||
unittest::optional_foreign_message_extension));
|
||||
EXPECT_NE(&unittest_import::ImportMessage::default_instance(),
|
||||
&message.GetExtension(unittest::optional_import_message_extension));
|
||||
|
||||
// Make sure setting stuff again after clearing works. (This takes slightly
|
||||
// different code paths since the objects are reused.)
|
||||
TestUtil::SetAllExtensions(&message);
|
||||
TestUtil::ExpectAllExtensionsSet(message);
|
||||
}
|
||||
|
||||
TEST(ExtensionSetTest, ClearOneField) {
|
||||
// Set every field to a unique value, then clear one value and insure that
|
||||
// only that one value is cleared.
|
||||
unittest::TestAllExtensions message;
|
||||
|
||||
TestUtil::SetAllExtensions(&message);
|
||||
int64 original_value =
|
||||
message.GetExtension(unittest::optional_int64_extension);
|
||||
|
||||
// Clear the field and make sure it shows up as cleared.
|
||||
message.ClearExtension(unittest::optional_int64_extension);
|
||||
EXPECT_FALSE(message.HasExtension(unittest::optional_int64_extension));
|
||||
EXPECT_EQ(0, message.GetExtension(unittest::optional_int64_extension));
|
||||
|
||||
// Other adjacent fields should not be cleared.
|
||||
EXPECT_TRUE(message.HasExtension(unittest::optional_int32_extension));
|
||||
EXPECT_TRUE(message.HasExtension(unittest::optional_uint32_extension));
|
||||
|
||||
// Make sure if we set it again, then all fields are set.
|
||||
message.SetExtension(unittest::optional_int64_extension, original_value);
|
||||
TestUtil::ExpectAllExtensionsSet(message);
|
||||
}
|
||||
|
||||
TEST(ExtensionSetTest, CopyFrom) {
|
||||
unittest::TestAllExtensions message1, message2;
|
||||
string data;
|
||||
|
||||
TestUtil::SetAllExtensions(&message1);
|
||||
message2.CopyFrom(message1);
|
||||
TestUtil::ExpectAllExtensionsSet(message2);
|
||||
}
|
||||
|
||||
TEST(ExtensionSetTest, CopyFromUpcasted) {
|
||||
unittest::TestAllExtensions message1, message2;
|
||||
string data;
|
||||
const Message& upcasted_message = message1;
|
||||
|
||||
TestUtil::SetAllExtensions(&message1);
|
||||
message2.CopyFrom(upcasted_message);
|
||||
TestUtil::ExpectAllExtensionsSet(message2);
|
||||
}
|
||||
|
||||
TEST(ExtensionSetTest, SwapWithEmpty) {
|
||||
unittest::TestAllExtensions message1, message2;
|
||||
TestUtil::SetAllExtensions(&message1);
|
||||
|
||||
TestUtil::ExpectAllExtensionsSet(message1);
|
||||
TestUtil::ExpectExtensionsClear(message2);
|
||||
message1.Swap(&message2);
|
||||
TestUtil::ExpectAllExtensionsSet(message2);
|
||||
TestUtil::ExpectExtensionsClear(message1);
|
||||
}
|
||||
|
||||
TEST(ExtensionSetTest, SwapWithSelf) {
|
||||
unittest::TestAllExtensions message;
|
||||
TestUtil::SetAllExtensions(&message);
|
||||
|
||||
TestUtil::ExpectAllExtensionsSet(message);
|
||||
message.Swap(&message);
|
||||
TestUtil::ExpectAllExtensionsSet(message);
|
||||
}
|
||||
|
||||
TEST(ExtensionSetTest, SerializationToArray) {
|
||||
// Serialize as TestAllExtensions and parse as TestAllTypes to insure wire
|
||||
// compatibility of extensions.
|
||||
//
|
||||
// This checks serialization to a flat array by explicitly reserving space in
|
||||
// the string and calling the generated message's
|
||||
// SerializeWithCachedSizesToArray.
|
||||
unittest::TestAllExtensions source;
|
||||
unittest::TestAllTypes destination;
|
||||
TestUtil::SetAllExtensions(&source);
|
||||
int size = source.ByteSize();
|
||||
string data;
|
||||
data.resize(size);
|
||||
uint8* target = reinterpret_cast<uint8*>(string_as_array(&data));
|
||||
uint8* end = source.SerializeWithCachedSizesToArray(target);
|
||||
EXPECT_EQ(size, end - target);
|
||||
EXPECT_TRUE(destination.ParseFromString(data));
|
||||
TestUtil::ExpectAllFieldsSet(destination);
|
||||
}
|
||||
|
||||
TEST(ExtensionSetTest, SerializationToStream) {
|
||||
// Serialize as TestAllExtensions and parse as TestAllTypes to insure wire
|
||||
// compatibility of extensions.
|
||||
//
|
||||
// This checks serialization to an output stream by creating an array output
|
||||
// stream that can only buffer 1 byte at a time - this prevents the message
|
||||
// from ever jumping to the fast path, ensuring that serialization happens via
|
||||
// the CodedOutputStream.
|
||||
unittest::TestAllExtensions source;
|
||||
unittest::TestAllTypes destination;
|
||||
TestUtil::SetAllExtensions(&source);
|
||||
int size = source.ByteSize();
|
||||
string data;
|
||||
data.resize(size);
|
||||
{
|
||||
io::ArrayOutputStream array_stream(string_as_array(&data), size, 1);
|
||||
io::CodedOutputStream output_stream(&array_stream);
|
||||
source.SerializeWithCachedSizes(&output_stream);
|
||||
ASSERT_FALSE(output_stream.HadError());
|
||||
}
|
||||
EXPECT_TRUE(destination.ParseFromString(data));
|
||||
TestUtil::ExpectAllFieldsSet(destination);
|
||||
}
|
||||
|
||||
TEST(ExtensionSetTest, PackedSerializationToArray) {
|
||||
// Serialize as TestPackedExtensions and parse as TestPackedTypes to insure
|
||||
// wire compatibility of extensions.
|
||||
//
|
||||
// This checks serialization to a flat array by explicitly reserving space in
|
||||
// the string and calling the generated message's
|
||||
// SerializeWithCachedSizesToArray.
|
||||
unittest::TestPackedExtensions source;
|
||||
unittest::TestPackedTypes destination;
|
||||
TestUtil::SetPackedExtensions(&source);
|
||||
int size = source.ByteSize();
|
||||
string data;
|
||||
data.resize(size);
|
||||
uint8* target = reinterpret_cast<uint8*>(string_as_array(&data));
|
||||
uint8* end = source.SerializeWithCachedSizesToArray(target);
|
||||
EXPECT_EQ(size, end - target);
|
||||
EXPECT_TRUE(destination.ParseFromString(data));
|
||||
TestUtil::ExpectPackedFieldsSet(destination);
|
||||
}
|
||||
|
||||
TEST(ExtensionSetTest, PackedSerializationToStream) {
|
||||
// Serialize as TestPackedExtensions and parse as TestPackedTypes to insure
|
||||
// wire compatibility of extensions.
|
||||
//
|
||||
// This checks serialization to an output stream by creating an array output
|
||||
// stream that can only buffer 1 byte at a time - this prevents the message
|
||||
// from ever jumping to the fast path, ensuring that serialization happens via
|
||||
// the CodedOutputStream.
|
||||
unittest::TestPackedExtensions source;
|
||||
unittest::TestPackedTypes destination;
|
||||
TestUtil::SetPackedExtensions(&source);
|
||||
int size = source.ByteSize();
|
||||
string data;
|
||||
data.resize(size);
|
||||
{
|
||||
io::ArrayOutputStream array_stream(string_as_array(&data), size, 1);
|
||||
io::CodedOutputStream output_stream(&array_stream);
|
||||
source.SerializeWithCachedSizes(&output_stream);
|
||||
ASSERT_FALSE(output_stream.HadError());
|
||||
}
|
||||
EXPECT_TRUE(destination.ParseFromString(data));
|
||||
TestUtil::ExpectPackedFieldsSet(destination);
|
||||
}
|
||||
|
||||
TEST(ExtensionSetTest, Parsing) {
|
||||
// Serialize as TestAllTypes and parse as TestAllExtensions.
|
||||
unittest::TestAllTypes source;
|
||||
unittest::TestAllExtensions destination;
|
||||
string data;
|
||||
|
||||
TestUtil::SetAllFields(&source);
|
||||
source.SerializeToString(&data);
|
||||
EXPECT_TRUE(destination.ParseFromString(data));
|
||||
TestUtil::ExpectAllExtensionsSet(destination);
|
||||
}
|
||||
|
||||
TEST(ExtensionSetTest, PackedParsing) {
|
||||
// Serialize as TestPackedTypes and parse as TestPackedExtensions.
|
||||
unittest::TestPackedTypes source;
|
||||
unittest::TestPackedExtensions destination;
|
||||
string data;
|
||||
|
||||
TestUtil::SetPackedFields(&source);
|
||||
source.SerializeToString(&data);
|
||||
EXPECT_TRUE(destination.ParseFromString(data));
|
||||
TestUtil::ExpectPackedExtensionsSet(destination);
|
||||
}
|
||||
|
||||
TEST(ExtensionSetTest, IsInitialized) {
|
||||
// Test that IsInitialized() returns false if required fields in nested
|
||||
// extensions are missing.
|
||||
unittest::TestAllExtensions message;
|
||||
|
||||
EXPECT_TRUE(message.IsInitialized());
|
||||
|
||||
message.MutableExtension(unittest::TestRequired::single);
|
||||
EXPECT_FALSE(message.IsInitialized());
|
||||
|
||||
message.MutableExtension(unittest::TestRequired::single)->set_a(1);
|
||||
EXPECT_FALSE(message.IsInitialized());
|
||||
message.MutableExtension(unittest::TestRequired::single)->set_b(2);
|
||||
EXPECT_FALSE(message.IsInitialized());
|
||||
message.MutableExtension(unittest::TestRequired::single)->set_c(3);
|
||||
EXPECT_TRUE(message.IsInitialized());
|
||||
|
||||
message.AddExtension(unittest::TestRequired::multi);
|
||||
EXPECT_FALSE(message.IsInitialized());
|
||||
|
||||
message.MutableExtension(unittest::TestRequired::multi, 0)->set_a(1);
|
||||
EXPECT_FALSE(message.IsInitialized());
|
||||
message.MutableExtension(unittest::TestRequired::multi, 0)->set_b(2);
|
||||
EXPECT_FALSE(message.IsInitialized());
|
||||
message.MutableExtension(unittest::TestRequired::multi, 0)->set_c(3);
|
||||
EXPECT_TRUE(message.IsInitialized());
|
||||
}
|
||||
|
||||
TEST(ExtensionSetTest, MutableString) {
|
||||
// Test the mutable string accessors.
|
||||
unittest::TestAllExtensions message;
|
||||
|
||||
message.MutableExtension(unittest::optional_string_extension)->assign("foo");
|
||||
EXPECT_TRUE(message.HasExtension(unittest::optional_string_extension));
|
||||
EXPECT_EQ("foo", message.GetExtension(unittest::optional_string_extension));
|
||||
|
||||
message.AddExtension(unittest::repeated_string_extension)->assign("bar");
|
||||
ASSERT_EQ(1, message.ExtensionSize(unittest::repeated_string_extension));
|
||||
EXPECT_EQ("bar",
|
||||
message.GetExtension(unittest::repeated_string_extension, 0));
|
||||
}
|
||||
|
||||
TEST(ExtensionSetTest, SpaceUsedExcludingSelf) {
|
||||
// Scalar primitive extensions should increase the extension set size by a
|
||||
// minimum of the size of the primitive type.
|
||||
#define TEST_SCALAR_EXTENSIONS_SPACE_USED(type, value) \
|
||||
do { \
|
||||
unittest::TestAllExtensions message; \
|
||||
const int base_size = message.SpaceUsed(); \
|
||||
message.SetExtension(unittest::optional_##type##_extension, value); \
|
||||
int min_expected_size = base_size + \
|
||||
sizeof(message.GetExtension(unittest::optional_##type##_extension)); \
|
||||
EXPECT_LE(min_expected_size, message.SpaceUsed()); \
|
||||
} while (0)
|
||||
|
||||
TEST_SCALAR_EXTENSIONS_SPACE_USED(int32 , 101);
|
||||
TEST_SCALAR_EXTENSIONS_SPACE_USED(int64 , 102);
|
||||
TEST_SCALAR_EXTENSIONS_SPACE_USED(uint32 , 103);
|
||||
TEST_SCALAR_EXTENSIONS_SPACE_USED(uint64 , 104);
|
||||
TEST_SCALAR_EXTENSIONS_SPACE_USED(sint32 , 105);
|
||||
TEST_SCALAR_EXTENSIONS_SPACE_USED(sint64 , 106);
|
||||
TEST_SCALAR_EXTENSIONS_SPACE_USED(fixed32 , 107);
|
||||
TEST_SCALAR_EXTENSIONS_SPACE_USED(fixed64 , 108);
|
||||
TEST_SCALAR_EXTENSIONS_SPACE_USED(sfixed32, 109);
|
||||
TEST_SCALAR_EXTENSIONS_SPACE_USED(sfixed64, 110);
|
||||
TEST_SCALAR_EXTENSIONS_SPACE_USED(float , 111);
|
||||
TEST_SCALAR_EXTENSIONS_SPACE_USED(double , 112);
|
||||
TEST_SCALAR_EXTENSIONS_SPACE_USED(bool , true);
|
||||
#undef TEST_SCALAR_EXTENSIONS_SPACE_USED
|
||||
{
|
||||
unittest::TestAllExtensions message;
|
||||
const int base_size = message.SpaceUsed();
|
||||
message.SetExtension(unittest::optional_nested_enum_extension,
|
||||
unittest::TestAllTypes::FOO);
|
||||
int min_expected_size = base_size +
|
||||
sizeof(message.GetExtension(unittest::optional_nested_enum_extension));
|
||||
EXPECT_LE(min_expected_size, message.SpaceUsed());
|
||||
}
|
||||
{
|
||||
// Strings may cause extra allocations depending on their length; ensure
|
||||
// that gets included as well.
|
||||
unittest::TestAllExtensions message;
|
||||
const int base_size = message.SpaceUsed();
|
||||
const string s("this is a fairly large string that will cause some "
|
||||
"allocation in order to store it in the extension");
|
||||
message.SetExtension(unittest::optional_string_extension, s);
|
||||
int min_expected_size = base_size + s.length();
|
||||
EXPECT_LE(min_expected_size, message.SpaceUsed());
|
||||
}
|
||||
{
|
||||
// Messages also have additional allocation that need to be counted.
|
||||
unittest::TestAllExtensions message;
|
||||
const int base_size = message.SpaceUsed();
|
||||
unittest::ForeignMessage foreign;
|
||||
foreign.set_c(42);
|
||||
message.MutableExtension(unittest::optional_foreign_message_extension)->
|
||||
CopyFrom(foreign);
|
||||
int min_expected_size = base_size + foreign.SpaceUsed();
|
||||
EXPECT_LE(min_expected_size, message.SpaceUsed());
|
||||
}
|
||||
|
||||
// Repeated primitive extensions will increase space used by at least a
|
||||
// RepeatedField<T>, and will cause additional allocations when the array
|
||||
// gets too big for the initial space.
|
||||
// This macro:
|
||||
// - Adds a value to the repeated extension, then clears it, establishing
|
||||
// the base size.
|
||||
// - Adds a small number of values, testing that it doesn't increase the
|
||||
// SpaceUsed()
|
||||
// - Adds a large number of values (requiring allocation in the repeated
|
||||
// field), and ensures that that allocation is included in SpaceUsed()
|
||||
#define TEST_REPEATED_EXTENSIONS_SPACE_USED(type, cpptype, value) \
|
||||
do { \
|
||||
unittest::TestAllExtensions message; \
|
||||
const int base_size = message.SpaceUsed(); \
|
||||
int min_expected_size = sizeof(RepeatedField<cpptype>) + base_size; \
|
||||
message.AddExtension(unittest::repeated_##type##_extension, value); \
|
||||
message.ClearExtension(unittest::repeated_##type##_extension); \
|
||||
const int empty_repeated_field_size = message.SpaceUsed(); \
|
||||
EXPECT_LE(min_expected_size, empty_repeated_field_size) << #type; \
|
||||
message.AddExtension(unittest::repeated_##type##_extension, value); \
|
||||
message.AddExtension(unittest::repeated_##type##_extension, value); \
|
||||
EXPECT_EQ(empty_repeated_field_size, message.SpaceUsed()) << #type; \
|
||||
message.ClearExtension(unittest::repeated_##type##_extension); \
|
||||
for (int i = 0; i < 16; ++i) { \
|
||||
message.AddExtension(unittest::repeated_##type##_extension, value); \
|
||||
} \
|
||||
int expected_size = sizeof(cpptype) * 16 + empty_repeated_field_size; \
|
||||
EXPECT_EQ(expected_size, message.SpaceUsed()) << #type; \
|
||||
} while (0)
|
||||
|
||||
TEST_REPEATED_EXTENSIONS_SPACE_USED(int32 , int32 , 101);
|
||||
TEST_REPEATED_EXTENSIONS_SPACE_USED(int64 , int64 , 102);
|
||||
TEST_REPEATED_EXTENSIONS_SPACE_USED(uint32 , uint32, 103);
|
||||
TEST_REPEATED_EXTENSIONS_SPACE_USED(uint64 , uint64, 104);
|
||||
TEST_REPEATED_EXTENSIONS_SPACE_USED(sint32 , int32 , 105);
|
||||
TEST_REPEATED_EXTENSIONS_SPACE_USED(sint64 , int64 , 106);
|
||||
TEST_REPEATED_EXTENSIONS_SPACE_USED(fixed32 , uint32, 107);
|
||||
TEST_REPEATED_EXTENSIONS_SPACE_USED(fixed64 , uint64, 108);
|
||||
TEST_REPEATED_EXTENSIONS_SPACE_USED(sfixed32, int32 , 109);
|
||||
TEST_REPEATED_EXTENSIONS_SPACE_USED(sfixed64, int64 , 110);
|
||||
TEST_REPEATED_EXTENSIONS_SPACE_USED(float , float , 111);
|
||||
TEST_REPEATED_EXTENSIONS_SPACE_USED(double , double, 112);
|
||||
TEST_REPEATED_EXTENSIONS_SPACE_USED(bool , bool , true);
|
||||
TEST_REPEATED_EXTENSIONS_SPACE_USED(nested_enum, int,
|
||||
unittest::TestAllTypes::FOO);
|
||||
#undef TEST_REPEATED_EXTENSIONS_SPACE_USED
|
||||
// Repeated strings
|
||||
{
|
||||
unittest::TestAllExtensions message;
|
||||
const int base_size = message.SpaceUsed();
|
||||
int min_expected_size = sizeof(RepeatedPtrField<string>) + base_size;
|
||||
const string value(256, 'x');
|
||||
// Once items are allocated, they may stick around even when cleared so
|
||||
// without the hardcore memory management accessors there isn't a notion of
|
||||
// the empty repeated field memory usage as there is with primitive types.
|
||||
for (int i = 0; i < 16; ++i) {
|
||||
message.AddExtension(unittest::repeated_string_extension, value);
|
||||
}
|
||||
min_expected_size += (sizeof(value) + value.size()) * 16;
|
||||
EXPECT_LE(min_expected_size, message.SpaceUsed());
|
||||
}
|
||||
// Repeated messages
|
||||
{
|
||||
unittest::TestAllExtensions message;
|
||||
const int base_size = message.SpaceUsed();
|
||||
int min_expected_size = sizeof(RepeatedPtrField<unittest::ForeignMessage>) +
|
||||
base_size;
|
||||
unittest::ForeignMessage prototype;
|
||||
prototype.set_c(2);
|
||||
for (int i = 0; i < 16; ++i) {
|
||||
message.AddExtension(unittest::repeated_foreign_message_extension)->
|
||||
CopyFrom(prototype);
|
||||
}
|
||||
min_expected_size += 16 * prototype.SpaceUsed();
|
||||
EXPECT_LE(min_expected_size, message.SpaceUsed());
|
||||
}
|
||||
}
|
||||
|
||||
#ifdef GTEST_HAS_DEATH_TEST
|
||||
|
||||
TEST(ExtensionSetTest, InvalidEnumDeath) {
|
||||
unittest::TestAllExtensions message;
|
||||
EXPECT_DEBUG_DEATH(
|
||||
message.SetExtension(unittest::optional_foreign_enum_extension,
|
||||
static_cast<unittest::ForeignEnum>(53)),
|
||||
"IsValid");
|
||||
}
|
||||
|
||||
#endif // GTEST_HAS_DEATH_TEST
|
||||
|
||||
TEST(ExtensionSetTest, DynamicExtensions) {
|
||||
// Test adding a dynamic extension to a compiled-in message object.
|
||||
|
||||
FileDescriptorProto dynamic_proto;
|
||||
dynamic_proto.set_name("dynamic_extensions_test.proto");
|
||||
dynamic_proto.add_dependency(
|
||||
unittest::TestAllExtensions::descriptor()->file()->name());
|
||||
dynamic_proto.set_package("dynamic_extensions");
|
||||
|
||||
// Copy the fields and nested types from TestDynamicExtensions into our new
|
||||
// proto, converting the fields into extensions.
|
||||
const Descriptor* template_descriptor =
|
||||
unittest::TestDynamicExtensions::descriptor();
|
||||
DescriptorProto template_descriptor_proto;
|
||||
template_descriptor->CopyTo(&template_descriptor_proto);
|
||||
dynamic_proto.mutable_message_type()->MergeFrom(
|
||||
template_descriptor_proto.nested_type());
|
||||
dynamic_proto.mutable_enum_type()->MergeFrom(
|
||||
template_descriptor_proto.enum_type());
|
||||
dynamic_proto.mutable_extension()->MergeFrom(
|
||||
template_descriptor_proto.field());
|
||||
|
||||
// For each extension that we added...
|
||||
for (int i = 0; i < dynamic_proto.extension_size(); i++) {
|
||||
// Set its extendee to TestAllExtensions.
|
||||
FieldDescriptorProto* extension = dynamic_proto.mutable_extension(i);
|
||||
extension->set_extendee(
|
||||
unittest::TestAllExtensions::descriptor()->full_name());
|
||||
|
||||
// If the field refers to one of the types nested in TestDynamicExtensions,
|
||||
// make it refer to the type in our dynamic proto instead.
|
||||
string prefix = "." + template_descriptor->full_name() + ".";
|
||||
if (extension->has_type_name()) {
|
||||
string* type_name = extension->mutable_type_name();
|
||||
if (HasPrefixString(*type_name, prefix)) {
|
||||
type_name->replace(0, prefix.size(), ".dynamic_extensions.");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Now build the file, using the generated pool as an underlay.
|
||||
DescriptorPool dynamic_pool(DescriptorPool::generated_pool());
|
||||
const FileDescriptor* file = dynamic_pool.BuildFile(dynamic_proto);
|
||||
ASSERT_TRUE(file != NULL);
|
||||
DynamicMessageFactory dynamic_factory(&dynamic_pool);
|
||||
dynamic_factory.SetDelegateToGeneratedFactory(true);
|
||||
|
||||
// Construct a message that we can parse with the extensions we defined.
|
||||
// Since the extensions were based off of the fields of TestDynamicExtensions,
|
||||
// we can use that message to create this test message.
|
||||
string data;
|
||||
{
|
||||
unittest::TestDynamicExtensions message;
|
||||
message.set_scalar_extension(123);
|
||||
message.set_enum_extension(unittest::FOREIGN_BAR);
|
||||
message.set_dynamic_enum_extension(
|
||||
unittest::TestDynamicExtensions::DYNAMIC_BAZ);
|
||||
message.mutable_message_extension()->set_c(456);
|
||||
message.mutable_dynamic_message_extension()->set_dynamic_field(789);
|
||||
message.add_repeated_extension("foo");
|
||||
message.add_repeated_extension("bar");
|
||||
message.add_packed_extension(12);
|
||||
message.add_packed_extension(-34);
|
||||
message.add_packed_extension(56);
|
||||
message.add_packed_extension(-78);
|
||||
|
||||
// Also add some unknown fields.
|
||||
|
||||
// An unknown enum value (for a known field).
|
||||
message.mutable_unknown_fields()->AddVarint(
|
||||
unittest::TestDynamicExtensions::kDynamicEnumExtensionFieldNumber,
|
||||
12345);
|
||||
// A regular unknown field.
|
||||
message.mutable_unknown_fields()->AddLengthDelimited(54321, "unknown");
|
||||
|
||||
message.SerializeToString(&data);
|
||||
}
|
||||
|
||||
// Now we can parse this using our dynamic extension definitions...
|
||||
unittest::TestAllExtensions message;
|
||||
{
|
||||
io::ArrayInputStream raw_input(data.data(), data.size());
|
||||
io::CodedInputStream input(&raw_input);
|
||||
input.SetExtensionRegistry(&dynamic_pool, &dynamic_factory);
|
||||
ASSERT_TRUE(message.ParseFromCodedStream(&input));
|
||||
ASSERT_TRUE(input.ConsumedEntireMessage());
|
||||
}
|
||||
|
||||
// Can we print it?
|
||||
EXPECT_EQ(
|
||||
"[dynamic_extensions.scalar_extension]: 123\n"
|
||||
"[dynamic_extensions.enum_extension]: FOREIGN_BAR\n"
|
||||
"[dynamic_extensions.dynamic_enum_extension]: DYNAMIC_BAZ\n"
|
||||
"[dynamic_extensions.message_extension] {\n"
|
||||
" c: 456\n"
|
||||
"}\n"
|
||||
"[dynamic_extensions.dynamic_message_extension] {\n"
|
||||
" dynamic_field: 789\n"
|
||||
"}\n"
|
||||
"[dynamic_extensions.repeated_extension]: \"foo\"\n"
|
||||
"[dynamic_extensions.repeated_extension]: \"bar\"\n"
|
||||
"[dynamic_extensions.packed_extension]: 12\n"
|
||||
"[dynamic_extensions.packed_extension]: -34\n"
|
||||
"[dynamic_extensions.packed_extension]: 56\n"
|
||||
"[dynamic_extensions.packed_extension]: -78\n"
|
||||
"2002: 12345\n"
|
||||
"54321: \"unknown\"\n",
|
||||
message.DebugString());
|
||||
|
||||
// Can we serialize it?
|
||||
// (Don't use EXPECT_EQ because we don't want to dump raw binary data to the
|
||||
// terminal on failure.)
|
||||
EXPECT_TRUE(message.SerializeAsString() == data);
|
||||
|
||||
// What if we parse using the reflection-based parser?
|
||||
{
|
||||
unittest::TestAllExtensions message2;
|
||||
io::ArrayInputStream raw_input(data.data(), data.size());
|
||||
io::CodedInputStream input(&raw_input);
|
||||
input.SetExtensionRegistry(&dynamic_pool, &dynamic_factory);
|
||||
ASSERT_TRUE(WireFormat::ParseAndMergePartial(&input, &message2));
|
||||
ASSERT_TRUE(input.ConsumedEntireMessage());
|
||||
EXPECT_EQ(message.DebugString(), message2.DebugString());
|
||||
}
|
||||
|
||||
// Are the embedded generated types actually using the generated objects?
|
||||
{
|
||||
const FieldDescriptor* message_extension =
|
||||
file->FindExtensionByName("message_extension");
|
||||
ASSERT_TRUE(message_extension != NULL);
|
||||
const Message& sub_message =
|
||||
message.GetReflection()->GetMessage(message, message_extension);
|
||||
const unittest::ForeignMessage* typed_sub_message =
|
||||
dynamic_cast<const unittest::ForeignMessage*>(&sub_message);
|
||||
ASSERT_TRUE(typed_sub_message != NULL);
|
||||
EXPECT_EQ(456, typed_sub_message->c());
|
||||
}
|
||||
|
||||
// What does GetMessage() return for the embedded dynamic type if it isn't
|
||||
// present?
|
||||
{
|
||||
const FieldDescriptor* dynamic_message_extension =
|
||||
file->FindExtensionByName("dynamic_message_extension");
|
||||
ASSERT_TRUE(dynamic_message_extension != NULL);
|
||||
const Message& parent = unittest::TestAllExtensions::default_instance();
|
||||
const Message& sub_message =
|
||||
parent.GetReflection()->GetMessage(parent, dynamic_message_extension,
|
||||
&dynamic_factory);
|
||||
const Message* prototype =
|
||||
dynamic_factory.GetPrototype(dynamic_message_extension->message_type());
|
||||
EXPECT_EQ(prototype, &sub_message);
|
||||
}
|
||||
}
|
||||
|
||||
} // namespace
|
||||
} // namespace internal
|
||||
} // namespace protobuf
|
||||
} // namespace google
|
||||
File diff suppressed because it is too large
Load Diff
@ -1,424 +0,0 @@
|
||||
// Protocol Buffers - Google's data interchange format
|
||||
// Copyright 2008 Google Inc. All rights reserved.
|
||||
// http://code.google.com/p/protobuf/
|
||||
//
|
||||
// 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.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// 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.
|
||||
|
||||
// Author: kenton@google.com (Kenton Varda)
|
||||
// Based on original Protocol Buffers design by
|
||||
// Sanjay Ghemawat, Jeff Dean, and others.
|
||||
//
|
||||
// This header is logically internal, but is made public because it is used
|
||||
// from protocol-compiler-generated code, which may reside in other components.
|
||||
|
||||
#ifndef GOOGLE_PROTOBUF_GENERATED_MESSAGE_REFLECTION_H__
|
||||
#define GOOGLE_PROTOBUF_GENERATED_MESSAGE_REFLECTION_H__
|
||||
|
||||
#include <string>
|
||||
#include <vector>
|
||||
#include <google/protobuf/message.h>
|
||||
#include <google/protobuf/unknown_field_set.h>
|
||||
|
||||
|
||||
namespace google {
|
||||
namespace protobuf {
|
||||
class DescriptorPool;
|
||||
// Generated code needs these to have been forward-declared. Easier to do it
|
||||
// here than to print them inside every .pb.h file.
|
||||
class FileDescriptor;
|
||||
class EnumDescriptor;
|
||||
}
|
||||
|
||||
namespace protobuf {
|
||||
namespace internal {
|
||||
|
||||
// Defined in this file.
|
||||
class GeneratedMessageReflection;
|
||||
|
||||
// Defined in other files.
|
||||
class ExtensionSet; // extension_set.h
|
||||
|
||||
// THIS CLASS IS NOT INTENDED FOR DIRECT USE. It is intended for use
|
||||
// by generated code. This class is just a big hack that reduces code
|
||||
// size.
|
||||
//
|
||||
// A GeneratedMessageReflection is an implementation of Reflection
|
||||
// which expects all fields to be backed by simple variables located in
|
||||
// memory. The locations are given using a base pointer and a set of
|
||||
// offsets.
|
||||
//
|
||||
// It is required that the user represents fields of each type in a standard
|
||||
// way, so that GeneratedMessageReflection can cast the void* pointer to
|
||||
// the appropriate type. For primitive fields and string fields, each field
|
||||
// should be represented using the obvious C++ primitive type. Enums and
|
||||
// Messages are different:
|
||||
// - Singular Message fields are stored as a pointer to a Message. These
|
||||
// should start out NULL, except for in the default instance where they
|
||||
// should start out pointing to other default instances.
|
||||
// - Enum fields are stored as an int. This int must always contain
|
||||
// a valid value, such that EnumDescriptor::FindValueByNumber() would
|
||||
// not return NULL.
|
||||
// - Repeated fields are stored as RepeatedFields or RepeatedPtrFields
|
||||
// of whatever type the individual field would be. Strings and
|
||||
// Messages use RepeatedPtrFields while everything else uses
|
||||
// RepeatedFields.
|
||||
class LIBPROTOBUF_EXPORT GeneratedMessageReflection : public Reflection {
|
||||
public:
|
||||
// Constructs a GeneratedMessageReflection.
|
||||
// Parameters:
|
||||
// descriptor: The descriptor for the message type being implemented.
|
||||
// default_instance: The default instance of the message. This is only
|
||||
// used to obtain pointers to default instances of embedded
|
||||
// messages, which GetMessage() will return if the particular
|
||||
// sub-message has not been initialized yet. (Thus, all
|
||||
// embedded message fields *must* have non-NULL pointers
|
||||
// in the default instance.)
|
||||
// offsets: An array of ints giving the byte offsets, relative to
|
||||
// the start of the message object, of each field. These can
|
||||
// be computed at compile time using the
|
||||
// GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET() macro, defined
|
||||
// below.
|
||||
// has_bits_offset: Offset in the message of an array of uint32s of size
|
||||
// descriptor->field_count()/32, rounded up. This is a
|
||||
// bitfield where each bit indicates whether or not the
|
||||
// corresponding field of the message has been initialized.
|
||||
// The bit for field index i is obtained by the expression:
|
||||
// has_bits[i / 32] & (1 << (i % 32))
|
||||
// unknown_fields_offset: Offset in the message of the UnknownFieldSet for
|
||||
// the message.
|
||||
// extensions_offset: Offset in the message of the ExtensionSet for the
|
||||
// message, or -1 if the message type has no extension
|
||||
// ranges.
|
||||
// pool: DescriptorPool to search for extension definitions. Only
|
||||
// used by FindKnownExtensionByName() and
|
||||
// FindKnownExtensionByNumber().
|
||||
// factory: MessageFactory to use to construct extension messages.
|
||||
// object_size: The size of a message object of this type, as measured
|
||||
// by sizeof().
|
||||
GeneratedMessageReflection(const Descriptor* descriptor,
|
||||
const Message* default_instance,
|
||||
const int offsets[],
|
||||
int has_bits_offset,
|
||||
int unknown_fields_offset,
|
||||
int extensions_offset,
|
||||
const DescriptorPool* pool,
|
||||
MessageFactory* factory,
|
||||
int object_size);
|
||||
~GeneratedMessageReflection();
|
||||
|
||||
// implements Reflection -------------------------------------------
|
||||
|
||||
const UnknownFieldSet& GetUnknownFields(const Message& message) const;
|
||||
UnknownFieldSet* MutableUnknownFields(Message* message) const;
|
||||
|
||||
int SpaceUsed(const Message& message) const;
|
||||
|
||||
bool HasField(const Message& message, const FieldDescriptor* field) const;
|
||||
int FieldSize(const Message& message, const FieldDescriptor* field) const;
|
||||
void ClearField(Message* message, const FieldDescriptor* field) const;
|
||||
void RemoveLast(Message* message, const FieldDescriptor* field) const;
|
||||
void Swap(Message* message1, Message* message2) const;
|
||||
void SwapElements(Message* message, const FieldDescriptor* field,
|
||||
int index1, int index2) const;
|
||||
void ListFields(const Message& message,
|
||||
vector<const FieldDescriptor*>* output) const;
|
||||
|
||||
int32 GetInt32 (const Message& message,
|
||||
const FieldDescriptor* field) const;
|
||||
int64 GetInt64 (const Message& message,
|
||||
const FieldDescriptor* field) const;
|
||||
uint32 GetUInt32(const Message& message,
|
||||
const FieldDescriptor* field) const;
|
||||
uint64 GetUInt64(const Message& message,
|
||||
const FieldDescriptor* field) const;
|
||||
float GetFloat (const Message& message,
|
||||
const FieldDescriptor* field) const;
|
||||
double GetDouble(const Message& message,
|
||||
const FieldDescriptor* field) const;
|
||||
bool GetBool (const Message& message,
|
||||
const FieldDescriptor* field) const;
|
||||
string GetString(const Message& message,
|
||||
const FieldDescriptor* field) const;
|
||||
const string& GetStringReference(const Message& message,
|
||||
const FieldDescriptor* field,
|
||||
string* scratch) const;
|
||||
const EnumValueDescriptor* GetEnum(const Message& message,
|
||||
const FieldDescriptor* field) const;
|
||||
const Message& GetMessage(const Message& message,
|
||||
const FieldDescriptor* field,
|
||||
MessageFactory* factory = NULL) const;
|
||||
|
||||
void SetInt32 (Message* message,
|
||||
const FieldDescriptor* field, int32 value) const;
|
||||
void SetInt64 (Message* message,
|
||||
const FieldDescriptor* field, int64 value) const;
|
||||
void SetUInt32(Message* message,
|
||||
const FieldDescriptor* field, uint32 value) const;
|
||||
void SetUInt64(Message* message,
|
||||
const FieldDescriptor* field, uint64 value) const;
|
||||
void SetFloat (Message* message,
|
||||
const FieldDescriptor* field, float value) const;
|
||||
void SetDouble(Message* message,
|
||||
const FieldDescriptor* field, double value) const;
|
||||
void SetBool (Message* message,
|
||||
const FieldDescriptor* field, bool value) const;
|
||||
void SetString(Message* message,
|
||||
const FieldDescriptor* field,
|
||||
const string& value) const;
|
||||
void SetEnum (Message* message, const FieldDescriptor* field,
|
||||
const EnumValueDescriptor* value) const;
|
||||
Message* MutableMessage(Message* message, const FieldDescriptor* field,
|
||||
MessageFactory* factory = NULL) const;
|
||||
|
||||
int32 GetRepeatedInt32 (const Message& message,
|
||||
const FieldDescriptor* field, int index) const;
|
||||
int64 GetRepeatedInt64 (const Message& message,
|
||||
const FieldDescriptor* field, int index) const;
|
||||
uint32 GetRepeatedUInt32(const Message& message,
|
||||
const FieldDescriptor* field, int index) const;
|
||||
uint64 GetRepeatedUInt64(const Message& message,
|
||||
const FieldDescriptor* field, int index) const;
|
||||
float GetRepeatedFloat (const Message& message,
|
||||
const FieldDescriptor* field, int index) const;
|
||||
double GetRepeatedDouble(const Message& message,
|
||||
const FieldDescriptor* field, int index) const;
|
||||
bool GetRepeatedBool (const Message& message,
|
||||
const FieldDescriptor* field, int index) const;
|
||||
string GetRepeatedString(const Message& message,
|
||||
const FieldDescriptor* field, int index) const;
|
||||
const string& GetRepeatedStringReference(const Message& message,
|
||||
const FieldDescriptor* field,
|
||||
int index, string* scratch) const;
|
||||
const EnumValueDescriptor* GetRepeatedEnum(const Message& message,
|
||||
const FieldDescriptor* field,
|
||||
int index) const;
|
||||
const Message& GetRepeatedMessage(const Message& message,
|
||||
const FieldDescriptor* field,
|
||||
int index) const;
|
||||
|
||||
// Set the value of a field.
|
||||
void SetRepeatedInt32 (Message* message,
|
||||
const FieldDescriptor* field, int index, int32 value) const;
|
||||
void SetRepeatedInt64 (Message* message,
|
||||
const FieldDescriptor* field, int index, int64 value) const;
|
||||
void SetRepeatedUInt32(Message* message,
|
||||
const FieldDescriptor* field, int index, uint32 value) const;
|
||||
void SetRepeatedUInt64(Message* message,
|
||||
const FieldDescriptor* field, int index, uint64 value) const;
|
||||
void SetRepeatedFloat (Message* message,
|
||||
const FieldDescriptor* field, int index, float value) const;
|
||||
void SetRepeatedDouble(Message* message,
|
||||
const FieldDescriptor* field, int index, double value) const;
|
||||
void SetRepeatedBool (Message* message,
|
||||
const FieldDescriptor* field, int index, bool value) const;
|
||||
void SetRepeatedString(Message* message,
|
||||
const FieldDescriptor* field, int index,
|
||||
const string& value) const;
|
||||
void SetRepeatedEnum(Message* message, const FieldDescriptor* field,
|
||||
int index, const EnumValueDescriptor* value) const;
|
||||
// Get a mutable pointer to a field with a message type.
|
||||
Message* MutableRepeatedMessage(Message* message,
|
||||
const FieldDescriptor* field,
|
||||
int index) const;
|
||||
|
||||
void AddInt32 (Message* message,
|
||||
const FieldDescriptor* field, int32 value) const;
|
||||
void AddInt64 (Message* message,
|
||||
const FieldDescriptor* field, int64 value) const;
|
||||
void AddUInt32(Message* message,
|
||||
const FieldDescriptor* field, uint32 value) const;
|
||||
void AddUInt64(Message* message,
|
||||
const FieldDescriptor* field, uint64 value) const;
|
||||
void AddFloat (Message* message,
|
||||
const FieldDescriptor* field, float value) const;
|
||||
void AddDouble(Message* message,
|
||||
const FieldDescriptor* field, double value) const;
|
||||
void AddBool (Message* message,
|
||||
const FieldDescriptor* field, bool value) const;
|
||||
void AddString(Message* message,
|
||||
const FieldDescriptor* field, const string& value) const;
|
||||
void AddEnum(Message* message,
|
||||
const FieldDescriptor* field,
|
||||
const EnumValueDescriptor* value) const;
|
||||
Message* AddMessage(Message* message, const FieldDescriptor* field,
|
||||
MessageFactory* factory = NULL) const;
|
||||
|
||||
const FieldDescriptor* FindKnownExtensionByName(const string& name) const;
|
||||
const FieldDescriptor* FindKnownExtensionByNumber(int number) const;
|
||||
|
||||
private:
|
||||
friend class GeneratedMessage;
|
||||
|
||||
const Descriptor* descriptor_;
|
||||
const Message* default_instance_;
|
||||
const int* offsets_;
|
||||
|
||||
int has_bits_offset_;
|
||||
int unknown_fields_offset_;
|
||||
int extensions_offset_;
|
||||
int object_size_;
|
||||
|
||||
const DescriptorPool* descriptor_pool_;
|
||||
MessageFactory* message_factory_;
|
||||
|
||||
template <typename Type>
|
||||
inline const Type& GetRaw(const Message& message,
|
||||
const FieldDescriptor* field) const;
|
||||
template <typename Type>
|
||||
inline Type* MutableRaw(Message* message,
|
||||
const FieldDescriptor* field) const;
|
||||
template <typename Type>
|
||||
inline const Type& DefaultRaw(const FieldDescriptor* field) const;
|
||||
inline const Message* GetMessagePrototype(const FieldDescriptor* field) const;
|
||||
|
||||
inline const uint32* GetHasBits(const Message& message) const;
|
||||
inline uint32* MutableHasBits(Message* message) const;
|
||||
inline const ExtensionSet& GetExtensionSet(const Message& message) const;
|
||||
inline ExtensionSet* MutableExtensionSet(Message* message) const;
|
||||
|
||||
inline bool HasBit(const Message& message,
|
||||
const FieldDescriptor* field) const;
|
||||
inline void SetBit(Message* message,
|
||||
const FieldDescriptor* field) const;
|
||||
inline void ClearBit(Message* message,
|
||||
const FieldDescriptor* field) const;
|
||||
|
||||
template <typename Type>
|
||||
inline const Type& GetField(const Message& message,
|
||||
const FieldDescriptor* field) const;
|
||||
template <typename Type>
|
||||
inline void SetField(Message* message,
|
||||
const FieldDescriptor* field, const Type& value) const;
|
||||
template <typename Type>
|
||||
inline Type* MutableField(Message* message,
|
||||
const FieldDescriptor* field) const;
|
||||
template <typename Type>
|
||||
inline const Type& GetRepeatedField(const Message& message,
|
||||
const FieldDescriptor* field,
|
||||
int index) const;
|
||||
template <typename Type>
|
||||
inline const Type& GetRepeatedPtrField(const Message& message,
|
||||
const FieldDescriptor* field,
|
||||
int index) const;
|
||||
template <typename Type>
|
||||
inline void SetRepeatedField(Message* message,
|
||||
const FieldDescriptor* field, int index,
|
||||
Type value) const;
|
||||
template <typename Type>
|
||||
inline Type* MutableRepeatedField(Message* message,
|
||||
const FieldDescriptor* field,
|
||||
int index) const;
|
||||
template <typename Type>
|
||||
inline void AddField(Message* message,
|
||||
const FieldDescriptor* field, const Type& value) const;
|
||||
template <typename Type>
|
||||
inline Type* AddField(Message* message,
|
||||
const FieldDescriptor* field) const;
|
||||
|
||||
int GetExtensionNumberOrDie(const Descriptor* type) const;
|
||||
|
||||
GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(GeneratedMessageReflection);
|
||||
};
|
||||
|
||||
// Returns the offset of the given field within the given aggregate type.
|
||||
// This is equivalent to the ANSI C offsetof() macro. However, according
|
||||
// to the C++ standard, offsetof() only works on POD types, and GCC
|
||||
// enforces this requirement with a warning. In practice, this rule is
|
||||
// unnecessarily strict; there is probably no compiler or platform on
|
||||
// which the offsets of the direct fields of a class are non-constant.
|
||||
// Fields inherited from superclasses *can* have non-constant offsets,
|
||||
// but that's not what this macro will be used for.
|
||||
//
|
||||
// Note that we calculate relative to the pointer value 16 here since if we
|
||||
// just use zero, GCC complains about dereferencing a NULL pointer. We
|
||||
// choose 16 rather than some other number just in case the compiler would
|
||||
// be confused by an unaligned pointer.
|
||||
#define GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(TYPE, FIELD) \
|
||||
static_cast<int>( \
|
||||
reinterpret_cast<const char*>( \
|
||||
&reinterpret_cast<const TYPE*>(16)->FIELD) - \
|
||||
reinterpret_cast<const char*>(16))
|
||||
|
||||
// There are some places in proto2 where dynamic_cast would be useful as an
|
||||
// optimization. For example, take Message::MergeFrom(const Message& other).
|
||||
// For a given generated message FooMessage, we generate these two methods:
|
||||
// void MergeFrom(const FooMessage& other);
|
||||
// void MergeFrom(const Message& other);
|
||||
// The former method can be implemented directly in terms of FooMessage's
|
||||
// inline accessors, but the latter method must work with the reflection
|
||||
// interface. However, if the parameter to the latter method is actually of
|
||||
// type FooMessage, then we'd like to be able to just call the other method
|
||||
// as an optimization. So, we use dynamic_cast to check this.
|
||||
//
|
||||
// That said, dynamic_cast requires RTTI, which many people like to disable
|
||||
// for performance and code size reasons. When RTTI is not available, we
|
||||
// still need to produce correct results. So, in this case we have to fall
|
||||
// back to using reflection, which is what we would have done anyway if the
|
||||
// objects were not of the exact same class.
|
||||
//
|
||||
// dynamic_cast_if_available() implements this logic. If RTTI is
|
||||
// enabled, it does a dynamic_cast. If RTTI is disabled, it just returns
|
||||
// NULL.
|
||||
//
|
||||
// If you need to compile without RTTI, simply #define GOOGLE_PROTOBUF_NO_RTTI.
|
||||
// On MSVC, this should be detected automatically.
|
||||
template<typename To, typename From>
|
||||
inline To dynamic_cast_if_available(From from) {
|
||||
#if defined(GOOGLE_PROTOBUF_NO_RTTI) || (defined(_MSC_VER)&&!defined(_CPPRTTI))
|
||||
return NULL;
|
||||
#else
|
||||
return dynamic_cast<To>(from);
|
||||
#endif
|
||||
}
|
||||
|
||||
// Helper for EnumType_Parse functions: try to parse the string 'name' as an
|
||||
// enum name of the given type, returning true and filling in value on success,
|
||||
// or returning false and leaving value unchanged on failure.
|
||||
LIBPROTOBUF_EXPORT bool ParseNamedEnum(const EnumDescriptor* descriptor,
|
||||
const string& name,
|
||||
int* value);
|
||||
|
||||
template<typename EnumType>
|
||||
bool ParseNamedEnum(const EnumDescriptor* descriptor,
|
||||
const string& name,
|
||||
EnumType* value) {
|
||||
int tmp;
|
||||
if (!ParseNamedEnum(descriptor, name, &tmp)) return false;
|
||||
*value = static_cast<EnumType>(tmp);
|
||||
return true;
|
||||
}
|
||||
|
||||
// Just a wrapper around printing the name of a value. The main point of this
|
||||
// function is not to be inlined, so that you can do this without including
|
||||
// descriptor.h.
|
||||
LIBPROTOBUF_EXPORT const string& NameOfEnum(const EnumDescriptor* descriptor, int value);
|
||||
|
||||
} // namespace internal
|
||||
} // namespace protobuf
|
||||
|
||||
} // namespace google
|
||||
#endif // GOOGLE_PROTOBUF_GENERATED_MESSAGE_REFLECTION_H__
|
||||
@ -1,839 +0,0 @@
|
||||
// Protocol Buffers - Google's data interchange format
|
||||
// Copyright 2008 Google Inc. All rights reserved.
|
||||
// http://code.google.com/p/protobuf/
|
||||
//
|
||||
// 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.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// 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.
|
||||
|
||||
// Author: kenton@google.com (Kenton Varda)
|
||||
// Based on original Protocol Buffers design by
|
||||
// Sanjay Ghemawat, Jeff Dean, and others.
|
||||
//
|
||||
// This implementation is heavily optimized to make reads and writes
|
||||
// of small values (especially varints) as fast as possible. In
|
||||
// particular, we optimize for the common case that a read or a write
|
||||
// will not cross the end of the buffer, since we can avoid a lot
|
||||
// of branching in this case.
|
||||
|
||||
#include <google/protobuf/io/coded_stream_inl.h>
|
||||
#include <algorithm>
|
||||
#include <limits.h>
|
||||
#include <google/protobuf/io/zero_copy_stream.h>
|
||||
#include <google/protobuf/stubs/common.h>
|
||||
#include <google/protobuf/stubs/stl_util-inl.h>
|
||||
|
||||
|
||||
namespace google {
|
||||
namespace protobuf {
|
||||
namespace io {
|
||||
|
||||
namespace {
|
||||
|
||||
static const int kMaxVarintBytes = 10;
|
||||
static const int kMaxVarint32Bytes = 5;
|
||||
|
||||
|
||||
inline bool NextNonEmpty(ZeroCopyInputStream* input,
|
||||
const void** data, int* size) {
|
||||
bool success;
|
||||
do {
|
||||
success = input->Next(data, size);
|
||||
} while (success && *size == 0);
|
||||
return success;
|
||||
}
|
||||
|
||||
} // namespace
|
||||
|
||||
// CodedInputStream ==================================================
|
||||
|
||||
|
||||
void CodedInputStream::BackUpInputToCurrentPosition() {
|
||||
int backup_bytes = BufferSize() + buffer_size_after_limit_ + overflow_bytes_;
|
||||
if (backup_bytes > 0) {
|
||||
input_->BackUp(backup_bytes);
|
||||
|
||||
// total_bytes_read_ doesn't include overflow_bytes_.
|
||||
total_bytes_read_ -= BufferSize() + buffer_size_after_limit_;
|
||||
buffer_end_ = buffer_;
|
||||
buffer_size_after_limit_ = 0;
|
||||
overflow_bytes_ = 0;
|
||||
}
|
||||
}
|
||||
|
||||
inline void CodedInputStream::RecomputeBufferLimits() {
|
||||
buffer_end_ += buffer_size_after_limit_;
|
||||
int closest_limit = min(current_limit_, total_bytes_limit_);
|
||||
if (closest_limit < total_bytes_read_) {
|
||||
// The limit position is in the current buffer. We must adjust
|
||||
// the buffer size accordingly.
|
||||
buffer_size_after_limit_ = total_bytes_read_ - closest_limit;
|
||||
buffer_end_ -= buffer_size_after_limit_;
|
||||
} else {
|
||||
buffer_size_after_limit_ = 0;
|
||||
}
|
||||
}
|
||||
|
||||
CodedInputStream::Limit CodedInputStream::PushLimit(int byte_limit) {
|
||||
// Current position relative to the beginning of the stream.
|
||||
int current_position = total_bytes_read_ -
|
||||
(BufferSize() + buffer_size_after_limit_);
|
||||
|
||||
Limit old_limit = current_limit_;
|
||||
|
||||
// security: byte_limit is possibly evil, so check for negative values
|
||||
// and overflow.
|
||||
if (byte_limit >= 0 &&
|
||||
byte_limit <= INT_MAX - current_position) {
|
||||
current_limit_ = current_position + byte_limit;
|
||||
} else {
|
||||
// Negative or overflow.
|
||||
current_limit_ = INT_MAX;
|
||||
}
|
||||
|
||||
// We need to enforce all limits, not just the new one, so if the previous
|
||||
// limit was before the new requested limit, we continue to enforce the
|
||||
// previous limit.
|
||||
current_limit_ = min(current_limit_, old_limit);
|
||||
|
||||
RecomputeBufferLimits();
|
||||
return old_limit;
|
||||
}
|
||||
|
||||
void CodedInputStream::PopLimit(Limit limit) {
|
||||
// The limit passed in is actually the *old* limit, which we returned from
|
||||
// PushLimit().
|
||||
current_limit_ = limit;
|
||||
RecomputeBufferLimits();
|
||||
|
||||
// We may no longer be at a legitimate message end. ReadTag() needs to be
|
||||
// called again to find out.
|
||||
legitimate_message_end_ = false;
|
||||
}
|
||||
|
||||
int CodedInputStream::BytesUntilLimit() {
|
||||
if (current_limit_ == INT_MAX) return -1;
|
||||
int current_position = total_bytes_read_ -
|
||||
(BufferSize() + buffer_size_after_limit_);
|
||||
|
||||
return current_limit_ - current_position;
|
||||
}
|
||||
|
||||
void CodedInputStream::SetTotalBytesLimit(
|
||||
int total_bytes_limit, int warning_threshold) {
|
||||
// Make sure the limit isn't already past, since this could confuse other
|
||||
// code.
|
||||
int current_position = total_bytes_read_ -
|
||||
(BufferSize() + buffer_size_after_limit_);
|
||||
total_bytes_limit_ = max(current_position, total_bytes_limit);
|
||||
total_bytes_warning_threshold_ = warning_threshold;
|
||||
RecomputeBufferLimits();
|
||||
}
|
||||
|
||||
void CodedInputStream::PrintTotalBytesLimitError() {
|
||||
GOOGLE_LOG(ERROR) << "A protocol message was rejected because it was too "
|
||||
"big (more than " << total_bytes_limit_
|
||||
<< " bytes). To increase the limit (or to disable these "
|
||||
"warnings), see CodedInputStream::SetTotalBytesLimit() "
|
||||
"in google/protobuf/io/coded_stream.h.";
|
||||
}
|
||||
|
||||
bool CodedInputStream::Skip(int count) {
|
||||
if (count < 0) return false; // security: count is often user-supplied
|
||||
|
||||
const int original_buffer_size = BufferSize();
|
||||
|
||||
if (count <= original_buffer_size) {
|
||||
// Just skipping within the current buffer. Easy.
|
||||
Advance(count);
|
||||
return true;
|
||||
}
|
||||
|
||||
if (buffer_size_after_limit_ > 0) {
|
||||
// We hit a limit inside this buffer. Advance to the limit and fail.
|
||||
Advance(original_buffer_size);
|
||||
return false;
|
||||
}
|
||||
|
||||
count -= original_buffer_size;
|
||||
buffer_ = NULL;
|
||||
buffer_end_ = buffer_;
|
||||
|
||||
// Make sure this skip doesn't try to skip past the current limit.
|
||||
int closest_limit = min(current_limit_, total_bytes_limit_);
|
||||
int bytes_until_limit = closest_limit - total_bytes_read_;
|
||||
if (bytes_until_limit < count) {
|
||||
// We hit the limit. Skip up to it then fail.
|
||||
if (bytes_until_limit > 0) {
|
||||
total_bytes_read_ = closest_limit;
|
||||
input_->Skip(bytes_until_limit);
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
total_bytes_read_ += count;
|
||||
return input_->Skip(count);
|
||||
}
|
||||
|
||||
bool CodedInputStream::GetDirectBufferPointer(const void** data, int* size) {
|
||||
if (BufferSize() == 0 && !Refresh()) return false;
|
||||
|
||||
*data = buffer_;
|
||||
*size = BufferSize();
|
||||
return true;
|
||||
}
|
||||
|
||||
bool CodedInputStream::ReadRaw(void* buffer, int size) {
|
||||
int current_buffer_size;
|
||||
while ((current_buffer_size = BufferSize()) < size) {
|
||||
// Reading past end of buffer. Copy what we have, then refresh.
|
||||
memcpy(buffer, buffer_, current_buffer_size);
|
||||
buffer = reinterpret_cast<uint8*>(buffer) + current_buffer_size;
|
||||
size -= current_buffer_size;
|
||||
Advance(current_buffer_size);
|
||||
if (!Refresh()) return false;
|
||||
}
|
||||
|
||||
memcpy(buffer, buffer_, size);
|
||||
Advance(size);
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
bool CodedInputStream::ReadString(string* buffer, int size) {
|
||||
if (size < 0) return false; // security: size is often user-supplied
|
||||
return InternalReadStringInline(buffer, size);
|
||||
}
|
||||
|
||||
bool CodedInputStream::ReadStringFallback(string* buffer, int size) {
|
||||
if (!buffer->empty()) {
|
||||
buffer->clear();
|
||||
}
|
||||
|
||||
int current_buffer_size;
|
||||
while ((current_buffer_size = BufferSize()) < size) {
|
||||
// Some STL implementations "helpfully" crash on buffer->append(NULL, 0).
|
||||
if (current_buffer_size != 0) {
|
||||
// Note: string1.append(string2) is O(string2.size()) (as opposed to
|
||||
// O(string1.size() + string2.size()), which would be bad).
|
||||
buffer->append(reinterpret_cast<const char*>(buffer_),
|
||||
current_buffer_size);
|
||||
}
|
||||
size -= current_buffer_size;
|
||||
Advance(current_buffer_size);
|
||||
if (!Refresh()) return false;
|
||||
}
|
||||
|
||||
buffer->append(reinterpret_cast<const char*>(buffer_), size);
|
||||
Advance(size);
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
bool CodedInputStream::ReadLittleEndian32Fallback(uint32* value) {
|
||||
uint8 bytes[sizeof(*value)];
|
||||
|
||||
const uint8* ptr;
|
||||
if (BufferSize() >= sizeof(*value)) {
|
||||
// Fast path: Enough bytes in the buffer to read directly.
|
||||
ptr = buffer_;
|
||||
Advance(sizeof(*value));
|
||||
} else {
|
||||
// Slow path: Had to read past the end of the buffer.
|
||||
if (!ReadRaw(bytes, sizeof(*value))) return false;
|
||||
ptr = bytes;
|
||||
}
|
||||
ReadLittleEndian32FromArray(ptr, value);
|
||||
return true;
|
||||
}
|
||||
|
||||
bool CodedInputStream::ReadLittleEndian64Fallback(uint64* value) {
|
||||
uint8 bytes[sizeof(*value)];
|
||||
|
||||
const uint8* ptr;
|
||||
if (BufferSize() >= sizeof(*value)) {
|
||||
// Fast path: Enough bytes in the buffer to read directly.
|
||||
ptr = buffer_;
|
||||
Advance(sizeof(*value));
|
||||
} else {
|
||||
// Slow path: Had to read past the end of the buffer.
|
||||
if (!ReadRaw(bytes, sizeof(*value))) return false;
|
||||
ptr = bytes;
|
||||
}
|
||||
ReadLittleEndian64FromArray(ptr, value);
|
||||
return true;
|
||||
}
|
||||
|
||||
namespace {
|
||||
|
||||
inline const uint8* ReadVarint32FromArray(
|
||||
const uint8* buffer, uint32* value) GOOGLE_ATTRIBUTE_ALWAYS_INLINE;
|
||||
inline const uint8* ReadVarint32FromArray(const uint8* buffer, uint32* value) {
|
||||
// Fast path: We have enough bytes left in the buffer to guarantee that
|
||||
// this read won't cross the end, so we can skip the checks.
|
||||
const uint8* ptr = buffer;
|
||||
uint32 b;
|
||||
uint32 result;
|
||||
|
||||
b = *(ptr++); result = (b & 0x7F) ; if (!(b & 0x80)) goto done;
|
||||
b = *(ptr++); result |= (b & 0x7F) << 7; if (!(b & 0x80)) goto done;
|
||||
b = *(ptr++); result |= (b & 0x7F) << 14; if (!(b & 0x80)) goto done;
|
||||
b = *(ptr++); result |= (b & 0x7F) << 21; if (!(b & 0x80)) goto done;
|
||||
b = *(ptr++); result |= b << 28; if (!(b & 0x80)) goto done;
|
||||
|
||||
// If the input is larger than 32 bits, we still need to read it all
|
||||
// and discard the high-order bits.
|
||||
for (int i = 0; i < kMaxVarintBytes - kMaxVarint32Bytes; i++) {
|
||||
b = *(ptr++); if (!(b & 0x80)) goto done;
|
||||
}
|
||||
|
||||
// We have overrun the maximum size of a varint (10 bytes). Assume
|
||||
// the data is corrupt.
|
||||
return NULL;
|
||||
|
||||
done:
|
||||
*value = result;
|
||||
return ptr;
|
||||
}
|
||||
|
||||
} // namespace
|
||||
|
||||
bool CodedInputStream::ReadVarint32Slow(uint32* value) {
|
||||
uint64 result;
|
||||
// Directly invoke ReadVarint64Fallback, since we already tried to optimize
|
||||
// for one-byte varints.
|
||||
if (!ReadVarint64Fallback(&result)) return false;
|
||||
*value = (uint32)result;
|
||||
return true;
|
||||
}
|
||||
|
||||
bool CodedInputStream::ReadVarint32Fallback(uint32* value) {
|
||||
if (BufferSize() >= kMaxVarintBytes ||
|
||||
// Optimization: If the varint ends at exactly the end of the buffer,
|
||||
// we can detect that and still use the fast path.
|
||||
(buffer_end_ > buffer_ && !(buffer_end_[-1] & 0x80))) {
|
||||
const uint8* end = ReadVarint32FromArray(buffer_, value);
|
||||
if (end == NULL) return false;
|
||||
buffer_ = end;
|
||||
return true;
|
||||
} else {
|
||||
// Really slow case: we will incur the cost of an extra function call here,
|
||||
// but moving this out of line reduces the size of this function, which
|
||||
// improves the common case. In micro benchmarks, this is worth about 10-15%
|
||||
return ReadVarint32Slow(value);
|
||||
}
|
||||
}
|
||||
|
||||
uint32 CodedInputStream::ReadTagSlow() {
|
||||
if (buffer_ == buffer_end_) {
|
||||
// Call refresh.
|
||||
if (!Refresh()) {
|
||||
// Refresh failed. Make sure that it failed due to EOF, not because
|
||||
// we hit total_bytes_limit_, which, unlike normal limits, is not a
|
||||
// valid place to end a message.
|
||||
int current_position = total_bytes_read_ - buffer_size_after_limit_;
|
||||
if (current_position >= total_bytes_limit_) {
|
||||
// Hit total_bytes_limit_. But if we also hit the normal limit,
|
||||
// we're still OK.
|
||||
legitimate_message_end_ = current_limit_ == total_bytes_limit_;
|
||||
} else {
|
||||
legitimate_message_end_ = true;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
// For the slow path, just do a 64-bit read. Try to optimize for one-byte tags
|
||||
// again, since we have now refreshed the buffer.
|
||||
uint64 result;
|
||||
if (!ReadVarint64(&result)) return 0;
|
||||
return static_cast<uint32>(result);
|
||||
}
|
||||
|
||||
uint32 CodedInputStream::ReadTagFallback() {
|
||||
if (BufferSize() >= kMaxVarintBytes ||
|
||||
// Optimization: If the varint ends at exactly the end of the buffer,
|
||||
// we can detect that and still use the fast path.
|
||||
(buffer_end_ > buffer_ && !(buffer_end_[-1] & 0x80))) {
|
||||
uint32 tag;
|
||||
const uint8* end = ReadVarint32FromArray(buffer_, &tag);
|
||||
if (end == NULL) {
|
||||
return 0;
|
||||
}
|
||||
buffer_ = end;
|
||||
return tag;
|
||||
} else {
|
||||
// We are commonly at a limit when attempting to read tags. Try to quickly
|
||||
// detect this case without making another function call.
|
||||
if (buffer_ == buffer_end_ && buffer_size_after_limit_ > 0 &&
|
||||
// Make sure that the limit we hit is not total_bytes_limit_, since
|
||||
// in that case we still need to call Refresh() so that it prints an
|
||||
// error.
|
||||
total_bytes_read_ - buffer_size_after_limit_ < total_bytes_limit_) {
|
||||
// We hit a byte limit.
|
||||
legitimate_message_end_ = true;
|
||||
return 0;
|
||||
}
|
||||
return ReadTagSlow();
|
||||
}
|
||||
}
|
||||
|
||||
bool CodedInputStream::ReadVarint64Slow(uint64* value) {
|
||||
// Slow path: This read might cross the end of the buffer, so we
|
||||
// need to check and refresh the buffer if and when it does.
|
||||
|
||||
uint64 result = 0;
|
||||
int count = 0;
|
||||
uint32 b;
|
||||
|
||||
do {
|
||||
if (count == kMaxVarintBytes) return false;
|
||||
while (buffer_ == buffer_end_) {
|
||||
if (!Refresh()) return false;
|
||||
}
|
||||
b = *buffer_;
|
||||
result |= static_cast<uint64>(b & 0x7F) << (7 * count);
|
||||
Advance(1);
|
||||
++count;
|
||||
} while (b & 0x80);
|
||||
|
||||
*value = result;
|
||||
return true;
|
||||
}
|
||||
|
||||
bool CodedInputStream::ReadVarint64Fallback(uint64* value) {
|
||||
if (BufferSize() >= kMaxVarintBytes ||
|
||||
// Optimization: If the varint ends at exactly the end of the buffer,
|
||||
// we can detect that and still use the fast path.
|
||||
(buffer_end_ > buffer_ && !(buffer_end_[-1] & 0x80))) {
|
||||
// Fast path: We have enough bytes left in the buffer to guarantee that
|
||||
// this read won't cross the end, so we can skip the checks.
|
||||
|
||||
const uint8* ptr = buffer_;
|
||||
uint32 b;
|
||||
|
||||
// Splitting into 32-bit pieces gives better performance on 32-bit
|
||||
// processors.
|
||||
uint32 part0 = 0, part1 = 0, part2 = 0;
|
||||
|
||||
b = *(ptr++); part0 = (b & 0x7F) ; if (!(b & 0x80)) goto done;
|
||||
b = *(ptr++); part0 |= (b & 0x7F) << 7; if (!(b & 0x80)) goto done;
|
||||
b = *(ptr++); part0 |= (b & 0x7F) << 14; if (!(b & 0x80)) goto done;
|
||||
b = *(ptr++); part0 |= (b & 0x7F) << 21; if (!(b & 0x80)) goto done;
|
||||
b = *(ptr++); part1 = (b & 0x7F) ; if (!(b & 0x80)) goto done;
|
||||
b = *(ptr++); part1 |= (b & 0x7F) << 7; if (!(b & 0x80)) goto done;
|
||||
b = *(ptr++); part1 |= (b & 0x7F) << 14; if (!(b & 0x80)) goto done;
|
||||
b = *(ptr++); part1 |= (b & 0x7F) << 21; if (!(b & 0x80)) goto done;
|
||||
b = *(ptr++); part2 = (b & 0x7F) ; if (!(b & 0x80)) goto done;
|
||||
b = *(ptr++); part2 |= (b & 0x7F) << 7; if (!(b & 0x80)) goto done;
|
||||
|
||||
// We have overrun the maximum size of a varint (10 bytes). The data
|
||||
// must be corrupt.
|
||||
return NULL;
|
||||
|
||||
done:
|
||||
Advance(ptr - buffer_);
|
||||
*value = (static_cast<uint64>(part0) ) |
|
||||
(static_cast<uint64>(part1) << 28) |
|
||||
(static_cast<uint64>(part2) << 56);
|
||||
return true;
|
||||
} else {
|
||||
return ReadVarint64Slow(value);
|
||||
}
|
||||
}
|
||||
|
||||
bool CodedInputStream::Refresh() {
|
||||
GOOGLE_DCHECK_EQ(0, BufferSize());
|
||||
|
||||
if (buffer_size_after_limit_ > 0 || overflow_bytes_ > 0 ||
|
||||
total_bytes_read_ == current_limit_) {
|
||||
// We've hit a limit. Stop.
|
||||
int current_position = total_bytes_read_ - buffer_size_after_limit_;
|
||||
|
||||
if (current_position >= total_bytes_limit_ &&
|
||||
total_bytes_limit_ != current_limit_) {
|
||||
// Hit total_bytes_limit_.
|
||||
PrintTotalBytesLimitError();
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
if (total_bytes_warning_threshold_ >= 0 &&
|
||||
total_bytes_read_ >= total_bytes_warning_threshold_) {
|
||||
GOOGLE_LOG(WARNING) << "Reading dangerously large protocol message. If the "
|
||||
"message turns out to be larger than "
|
||||
<< total_bytes_limit_ << " bytes, parsing will be halted "
|
||||
"for security reasons. To increase the limit (or to "
|
||||
"disable these warnings), see "
|
||||
"CodedInputStream::SetTotalBytesLimit() in "
|
||||
"google/protobuf/io/coded_stream.h.";
|
||||
|
||||
// Don't warn again for this stream.
|
||||
total_bytes_warning_threshold_ = -1;
|
||||
}
|
||||
|
||||
const void* void_buffer;
|
||||
int buffer_size;
|
||||
if (NextNonEmpty(input_, &void_buffer, &buffer_size)) {
|
||||
buffer_ = reinterpret_cast<const uint8*>(void_buffer);
|
||||
buffer_end_ = buffer_ + buffer_size;
|
||||
GOOGLE_CHECK_GE(buffer_size, 0);
|
||||
|
||||
if (total_bytes_read_ <= INT_MAX - buffer_size) {
|
||||
total_bytes_read_ += buffer_size;
|
||||
} else {
|
||||
// Overflow. Reset buffer_end_ to not include the bytes beyond INT_MAX.
|
||||
// We can't get that far anyway, because total_bytes_limit_ is guaranteed
|
||||
// to be less than it. We need to keep track of the number of bytes
|
||||
// we discarded, though, so that we can call input_->BackUp() to back
|
||||
// up over them on destruction.
|
||||
|
||||
// The following line is equivalent to:
|
||||
// overflow_bytes_ = total_bytes_read_ + buffer_size - INT_MAX;
|
||||
// except that it avoids overflows. Signed integer overflow has
|
||||
// undefined results according to the C standard.
|
||||
overflow_bytes_ = total_bytes_read_ - (INT_MAX - buffer_size);
|
||||
buffer_end_ -= overflow_bytes_;
|
||||
total_bytes_read_ = INT_MAX;
|
||||
}
|
||||
|
||||
RecomputeBufferLimits();
|
||||
return true;
|
||||
} else {
|
||||
buffer_ = NULL;
|
||||
buffer_end_ = NULL;
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
// CodedOutputStream =================================================
|
||||
|
||||
CodedOutputStream::CodedOutputStream(ZeroCopyOutputStream* output)
|
||||
: output_(output),
|
||||
buffer_(NULL),
|
||||
buffer_size_(0),
|
||||
total_bytes_(0),
|
||||
had_error_(false) {
|
||||
// Eagerly Refresh() so buffer space is immediately available.
|
||||
Refresh();
|
||||
// The Refresh() may have failed. If the client doesn't write any data,
|
||||
// though, don't consider this an error. If the client does write data, then
|
||||
// another Refresh() will be attempted and it will set the error once again.
|
||||
had_error_ = false;
|
||||
}
|
||||
|
||||
CodedOutputStream::~CodedOutputStream() {
|
||||
if (buffer_size_ > 0) {
|
||||
output_->BackUp(buffer_size_);
|
||||
}
|
||||
}
|
||||
|
||||
bool CodedOutputStream::Skip(int count) {
|
||||
if (count < 0) return false;
|
||||
|
||||
while (count > buffer_size_) {
|
||||
count -= buffer_size_;
|
||||
if (!Refresh()) return false;
|
||||
}
|
||||
|
||||
Advance(count);
|
||||
return true;
|
||||
}
|
||||
|
||||
bool CodedOutputStream::GetDirectBufferPointer(void** data, int* size) {
|
||||
if (buffer_size_ == 0 && !Refresh()) return false;
|
||||
|
||||
*data = buffer_;
|
||||
*size = buffer_size_;
|
||||
return true;
|
||||
}
|
||||
|
||||
void CodedOutputStream::WriteRaw(const void* data, int size) {
|
||||
while (buffer_size_ < size) {
|
||||
memcpy(buffer_, data, buffer_size_);
|
||||
size -= buffer_size_;
|
||||
data = reinterpret_cast<const uint8*>(data) + buffer_size_;
|
||||
if (!Refresh()) return;
|
||||
}
|
||||
|
||||
memcpy(buffer_, data, size);
|
||||
Advance(size);
|
||||
}
|
||||
|
||||
uint8* CodedOutputStream::WriteRawToArray(
|
||||
const void* data, int size, uint8* target) {
|
||||
memcpy(target, data, size);
|
||||
return target + size;
|
||||
}
|
||||
|
||||
|
||||
void CodedOutputStream::WriteLittleEndian32(uint32 value) {
|
||||
uint8 bytes[sizeof(value)];
|
||||
|
||||
bool use_fast = buffer_size_ >= sizeof(value);
|
||||
uint8* ptr = use_fast ? buffer_ : bytes;
|
||||
|
||||
WriteLittleEndian32ToArray(value, ptr);
|
||||
|
||||
if (use_fast) {
|
||||
Advance(sizeof(value));
|
||||
} else {
|
||||
WriteRaw(bytes, sizeof(value));
|
||||
}
|
||||
}
|
||||
|
||||
void CodedOutputStream::WriteLittleEndian64(uint64 value) {
|
||||
uint8 bytes[sizeof(value)];
|
||||
|
||||
bool use_fast = buffer_size_ >= sizeof(value);
|
||||
uint8* ptr = use_fast ? buffer_ : bytes;
|
||||
|
||||
WriteLittleEndian64ToArray(value, ptr);
|
||||
|
||||
if (use_fast) {
|
||||
Advance(sizeof(value));
|
||||
} else {
|
||||
WriteRaw(bytes, sizeof(value));
|
||||
}
|
||||
}
|
||||
|
||||
inline uint8* CodedOutputStream::WriteVarint32FallbackToArrayInline(
|
||||
uint32 value, uint8* target) {
|
||||
target[0] = static_cast<uint8>(value | 0x80);
|
||||
if (value >= (1 << 7)) {
|
||||
target[1] = static_cast<uint8>((value >> 7) | 0x80);
|
||||
if (value >= (1 << 14)) {
|
||||
target[2] = static_cast<uint8>((value >> 14) | 0x80);
|
||||
if (value >= (1 << 21)) {
|
||||
target[3] = static_cast<uint8>((value >> 21) | 0x80);
|
||||
if (value >= (1 << 28)) {
|
||||
target[4] = static_cast<uint8>(value >> 28);
|
||||
return target + 5;
|
||||
} else {
|
||||
target[3] &= 0x7F;
|
||||
return target + 4;
|
||||
}
|
||||
} else {
|
||||
target[2] &= 0x7F;
|
||||
return target + 3;
|
||||
}
|
||||
} else {
|
||||
target[1] &= 0x7F;
|
||||
return target + 2;
|
||||
}
|
||||
} else {
|
||||
target[0] &= 0x7F;
|
||||
return target + 1;
|
||||
}
|
||||
}
|
||||
|
||||
void CodedOutputStream::WriteVarint32(uint32 value) {
|
||||
if (buffer_size_ >= kMaxVarint32Bytes) {
|
||||
// Fast path: We have enough bytes left in the buffer to guarantee that
|
||||
// this write won't cross the end, so we can skip the checks.
|
||||
uint8* target = buffer_;
|
||||
uint8* end = WriteVarint32FallbackToArrayInline(value, target);
|
||||
int size = end - target;
|
||||
Advance(size);
|
||||
} else {
|
||||
// Slow path: This write might cross the end of the buffer, so we
|
||||
// compose the bytes first then use WriteRaw().
|
||||
uint8 bytes[kMaxVarint32Bytes];
|
||||
int size = 0;
|
||||
while (value > 0x7F) {
|
||||
bytes[size++] = (static_cast<uint8>(value) & 0x7F) | 0x80;
|
||||
value >>= 7;
|
||||
}
|
||||
bytes[size++] = static_cast<uint8>(value) & 0x7F;
|
||||
WriteRaw(bytes, size);
|
||||
}
|
||||
}
|
||||
|
||||
uint8* CodedOutputStream::WriteVarint32FallbackToArray(
|
||||
uint32 value, uint8* target) {
|
||||
return WriteVarint32FallbackToArrayInline(value, target);
|
||||
}
|
||||
|
||||
inline uint8* CodedOutputStream::WriteVarint64ToArrayInline(
|
||||
uint64 value, uint8* target) {
|
||||
// Splitting into 32-bit pieces gives better performance on 32-bit
|
||||
// processors.
|
||||
uint32 part0 = static_cast<uint32>(value );
|
||||
uint32 part1 = static_cast<uint32>(value >> 28);
|
||||
uint32 part2 = static_cast<uint32>(value >> 56);
|
||||
|
||||
int size;
|
||||
|
||||
// Here we can't really optimize for small numbers, since the value is
|
||||
// split into three parts. Cheking for numbers < 128, for instance,
|
||||
// would require three comparisons, since you'd have to make sure part1
|
||||
// and part2 are zero. However, if the caller is using 64-bit integers,
|
||||
// it is likely that they expect the numbers to often be very large, so
|
||||
// we probably don't want to optimize for small numbers anyway. Thus,
|
||||
// we end up with a hardcoded binary search tree...
|
||||
if (part2 == 0) {
|
||||
if (part1 == 0) {
|
||||
if (part0 < (1 << 14)) {
|
||||
if (part0 < (1 << 7)) {
|
||||
size = 1; goto size1;
|
||||
} else {
|
||||
size = 2; goto size2;
|
||||
}
|
||||
} else {
|
||||
if (part0 < (1 << 21)) {
|
||||
size = 3; goto size3;
|
||||
} else {
|
||||
size = 4; goto size4;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
if (part1 < (1 << 14)) {
|
||||
if (part1 < (1 << 7)) {
|
||||
size = 5; goto size5;
|
||||
} else {
|
||||
size = 6; goto size6;
|
||||
}
|
||||
} else {
|
||||
if (part1 < (1 << 21)) {
|
||||
size = 7; goto size7;
|
||||
} else {
|
||||
size = 8; goto size8;
|
||||
}
|
||||
}
|
||||
}
|
||||
} else {
|
||||
if (part2 < (1 << 7)) {
|
||||
size = 9; goto size9;
|
||||
} else {
|
||||
size = 10; goto size10;
|
||||
}
|
||||
}
|
||||
|
||||
GOOGLE_LOG(FATAL) << "Can't get here.";
|
||||
|
||||
size10: target[9] = static_cast<uint8>((part2 >> 7) | 0x80);
|
||||
size9 : target[8] = static_cast<uint8>((part2 ) | 0x80);
|
||||
size8 : target[7] = static_cast<uint8>((part1 >> 21) | 0x80);
|
||||
size7 : target[6] = static_cast<uint8>((part1 >> 14) | 0x80);
|
||||
size6 : target[5] = static_cast<uint8>((part1 >> 7) | 0x80);
|
||||
size5 : target[4] = static_cast<uint8>((part1 ) | 0x80);
|
||||
size4 : target[3] = static_cast<uint8>((part0 >> 21) | 0x80);
|
||||
size3 : target[2] = static_cast<uint8>((part0 >> 14) | 0x80);
|
||||
size2 : target[1] = static_cast<uint8>((part0 >> 7) | 0x80);
|
||||
size1 : target[0] = static_cast<uint8>((part0 ) | 0x80);
|
||||
|
||||
target[size-1] &= 0x7F;
|
||||
return target + size;
|
||||
}
|
||||
|
||||
void CodedOutputStream::WriteVarint64(uint64 value) {
|
||||
if (buffer_size_ >= kMaxVarintBytes) {
|
||||
// Fast path: We have enough bytes left in the buffer to guarantee that
|
||||
// this write won't cross the end, so we can skip the checks.
|
||||
uint8* target = buffer_;
|
||||
|
||||
uint8* end = WriteVarint64ToArrayInline(value, target);
|
||||
int size = end - target;
|
||||
Advance(size);
|
||||
} else {
|
||||
// Slow path: This write might cross the end of the buffer, so we
|
||||
// compose the bytes first then use WriteRaw().
|
||||
uint8 bytes[kMaxVarintBytes];
|
||||
int size = 0;
|
||||
while (value > 0x7F) {
|
||||
bytes[size++] = (static_cast<uint8>(value) & 0x7F) | 0x80;
|
||||
value >>= 7;
|
||||
}
|
||||
bytes[size++] = static_cast<uint8>(value) & 0x7F;
|
||||
WriteRaw(bytes, size);
|
||||
}
|
||||
}
|
||||
|
||||
uint8* CodedOutputStream::WriteVarint64ToArray(
|
||||
uint64 value, uint8* target) {
|
||||
return WriteVarint64ToArrayInline(value, target);
|
||||
}
|
||||
|
||||
bool CodedOutputStream::Refresh() {
|
||||
void* void_buffer;
|
||||
if (output_->Next(&void_buffer, &buffer_size_)) {
|
||||
buffer_ = reinterpret_cast<uint8*>(void_buffer);
|
||||
total_bytes_ += buffer_size_;
|
||||
return true;
|
||||
} else {
|
||||
buffer_ = NULL;
|
||||
buffer_size_ = 0;
|
||||
had_error_ = true;
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
int CodedOutputStream::VarintSize32Fallback(uint32 value) {
|
||||
if (value < (1 << 7)) {
|
||||
return 1;
|
||||
} else if (value < (1 << 14)) {
|
||||
return 2;
|
||||
} else if (value < (1 << 21)) {
|
||||
return 3;
|
||||
} else if (value < (1 << 28)) {
|
||||
return 4;
|
||||
} else {
|
||||
return 5;
|
||||
}
|
||||
}
|
||||
|
||||
int CodedOutputStream::VarintSize64(uint64 value) {
|
||||
if (value < (1ull << 35)) {
|
||||
if (value < (1ull << 7)) {
|
||||
return 1;
|
||||
} else if (value < (1ull << 14)) {
|
||||
return 2;
|
||||
} else if (value < (1ull << 21)) {
|
||||
return 3;
|
||||
} else if (value < (1ull << 28)) {
|
||||
return 4;
|
||||
} else {
|
||||
return 5;
|
||||
}
|
||||
} else {
|
||||
if (value < (1ull << 42)) {
|
||||
return 6;
|
||||
} else if (value < (1ull << 49)) {
|
||||
return 7;
|
||||
} else if (value < (1ull << 56)) {
|
||||
return 8;
|
||||
} else if (value < (1ull << 63)) {
|
||||
return 9;
|
||||
} else {
|
||||
return 10;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
} // namespace io
|
||||
} // namespace protobuf
|
||||
} // namespace google
|
||||
File diff suppressed because it is too large
Load Diff
@ -1,199 +0,0 @@
|
||||
// Protocol Buffers - Google's data interchange format
|
||||
// Copyright 2008 Google Inc. All rights reserved.
|
||||
// http://code.google.com/p/protobuf/
|
||||
//
|
||||
// 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.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// 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.
|
||||
|
||||
// Author: kenton@google.com (Kenton Varda)
|
||||
// Based on original Protocol Buffers design by
|
||||
// Sanjay Ghemawat, Jeff Dean, and others.
|
||||
|
||||
#include <google/protobuf/io/printer.h>
|
||||
#include <google/protobuf/io/zero_copy_stream.h>
|
||||
#include <google/protobuf/stubs/common.h>
|
||||
#include <google/protobuf/stubs/strutil.h>
|
||||
|
||||
namespace google {
|
||||
namespace protobuf {
|
||||
namespace io {
|
||||
|
||||
Printer::Printer(ZeroCopyOutputStream* output, char variable_delimiter)
|
||||
: variable_delimiter_(variable_delimiter),
|
||||
output_(output),
|
||||
buffer_(NULL),
|
||||
buffer_size_(0),
|
||||
at_start_of_line_(true),
|
||||
failed_(false) {
|
||||
}
|
||||
|
||||
Printer::~Printer() {
|
||||
// Only BackUp() if we're sure we've successfully called Next() at least once.
|
||||
if (buffer_size_ > 0) {
|
||||
output_->BackUp(buffer_size_);
|
||||
}
|
||||
}
|
||||
|
||||
void Printer::Print(const map<string, string>& variables, const char* text) {
|
||||
int size = strlen(text);
|
||||
int pos = 0; // The number of bytes we've written so far.
|
||||
|
||||
for (int i = 0; i < size; i++) {
|
||||
if (text[i] == '\n') {
|
||||
// Saw newline. If there is more text, we may need to insert an indent
|
||||
// here. So, write what we have so far, including the '\n'.
|
||||
WriteRaw(text + pos, i - pos + 1);
|
||||
pos = i + 1;
|
||||
|
||||
// Setting this true will cause the next WriteRaw() to insert an indent
|
||||
// first.
|
||||
at_start_of_line_ = true;
|
||||
|
||||
} else if (text[i] == variable_delimiter_) {
|
||||
// Saw the start of a variable name.
|
||||
|
||||
// Write what we have so far.
|
||||
WriteRaw(text + pos, i - pos);
|
||||
pos = i + 1;
|
||||
|
||||
// Find closing delimiter.
|
||||
const char* end = strchr(text + pos, variable_delimiter_);
|
||||
if (end == NULL) {
|
||||
GOOGLE_LOG(DFATAL) << " Unclosed variable name.";
|
||||
end = text + pos;
|
||||
}
|
||||
int endpos = end - text;
|
||||
|
||||
string varname(text + pos, endpos - pos);
|
||||
if (varname.empty()) {
|
||||
// Two delimiters in a row reduce to a literal delimiter character.
|
||||
WriteRaw(&variable_delimiter_, 1);
|
||||
} else {
|
||||
// Replace with the variable's value.
|
||||
map<string, string>::const_iterator iter = variables.find(varname);
|
||||
if (iter == variables.end()) {
|
||||
GOOGLE_LOG(DFATAL) << " Undefined variable: " << varname;
|
||||
} else {
|
||||
WriteRaw(iter->second.data(), iter->second.size());
|
||||
}
|
||||
}
|
||||
|
||||
// Advance past this variable.
|
||||
i = endpos;
|
||||
pos = endpos + 1;
|
||||
}
|
||||
}
|
||||
|
||||
// Write the rest.
|
||||
WriteRaw(text + pos, size - pos);
|
||||
}
|
||||
|
||||
void Printer::Print(const char* text) {
|
||||
static map<string, string> empty;
|
||||
Print(empty, text);
|
||||
}
|
||||
|
||||
void Printer::Print(const char* text,
|
||||
const char* variable, const string& value) {
|
||||
map<string, string> vars;
|
||||
vars[variable] = value;
|
||||
Print(vars, text);
|
||||
}
|
||||
|
||||
void Printer::Print(const char* text,
|
||||
const char* variable1, const string& value1,
|
||||
const char* variable2, const string& value2) {
|
||||
map<string, string> vars;
|
||||
vars[variable1] = value1;
|
||||
vars[variable2] = value2;
|
||||
Print(vars, text);
|
||||
}
|
||||
|
||||
void Printer::Print(const char* text,
|
||||
const char* variable1, const string& value1,
|
||||
const char* variable2, const string& value2,
|
||||
const char* variable3, const string& value3) {
|
||||
map<string, string> vars;
|
||||
vars[variable1] = value1;
|
||||
vars[variable2] = value2;
|
||||
vars[variable3] = value3;
|
||||
Print(vars, text);
|
||||
}
|
||||
|
||||
void Printer::Indent() {
|
||||
indent_ += " ";
|
||||
}
|
||||
|
||||
void Printer::Outdent() {
|
||||
if (indent_.empty()) {
|
||||
GOOGLE_LOG(DFATAL) << " Outdent() without matching Indent().";
|
||||
return;
|
||||
}
|
||||
|
||||
indent_.resize(indent_.size() - 2);
|
||||
}
|
||||
|
||||
void Printer::PrintRaw(const string& data) {
|
||||
WriteRaw(data.data(), data.size());
|
||||
}
|
||||
|
||||
void Printer::PrintRaw(const char* data) {
|
||||
if (failed_) return;
|
||||
WriteRaw(data, strlen(data));
|
||||
}
|
||||
|
||||
void Printer::WriteRaw(const char* data, int size) {
|
||||
if (failed_) return;
|
||||
if (size == 0) return;
|
||||
|
||||
if (at_start_of_line_) {
|
||||
// Insert an indent.
|
||||
at_start_of_line_ = false;
|
||||
WriteRaw(indent_.data(), indent_.size());
|
||||
if (failed_) return;
|
||||
}
|
||||
|
||||
while (size > buffer_size_) {
|
||||
// Data exceeds space in the buffer. Copy what we can and request a
|
||||
// new buffer.
|
||||
memcpy(buffer_, data, buffer_size_);
|
||||
data += buffer_size_;
|
||||
size -= buffer_size_;
|
||||
void* void_buffer;
|
||||
failed_ = !output_->Next(&void_buffer, &buffer_size_);
|
||||
if (failed_) return;
|
||||
buffer_ = reinterpret_cast<char*>(void_buffer);
|
||||
}
|
||||
|
||||
// Buffer is big enough to receive the data; copy it.
|
||||
memcpy(buffer_, data, size);
|
||||
buffer_ += size;
|
||||
buffer_size_ -= size;
|
||||
}
|
||||
|
||||
} // namespace io
|
||||
} // namespace protobuf
|
||||
} // namespace google
|
||||
@ -1,136 +0,0 @@
|
||||
// Protocol Buffers - Google's data interchange format
|
||||
// Copyright 2008 Google Inc. All rights reserved.
|
||||
// http://code.google.com/p/protobuf/
|
||||
//
|
||||
// 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.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// 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.
|
||||
|
||||
// Author: kenton@google.com (Kenton Varda)
|
||||
// Based on original Protocol Buffers design by
|
||||
// Sanjay Ghemawat, Jeff Dean, and others.
|
||||
//
|
||||
// Utility class for writing text to a ZeroCopyOutputStream.
|
||||
|
||||
#ifndef GOOGLE_PROTOBUF_IO_PRINTER_H__
|
||||
#define GOOGLE_PROTOBUF_IO_PRINTER_H__
|
||||
|
||||
#include <string>
|
||||
#include <map>
|
||||
#include <google/protobuf/stubs/common.h>
|
||||
|
||||
namespace google {
|
||||
namespace protobuf {
|
||||
namespace io {
|
||||
|
||||
class ZeroCopyOutputStream; // zero_copy_stream.h
|
||||
|
||||
// This simple utility class assists in code generation. It basically
|
||||
// allows the caller to define a set of variables and then output some
|
||||
// text with variable substitutions. Example usage:
|
||||
//
|
||||
// Printer printer(output, '$');
|
||||
// map<string, string> vars;
|
||||
// vars["name"] = "Bob";
|
||||
// printer.Print(vars, "My name is $name$.");
|
||||
//
|
||||
// The above writes "My name is Bob." to the output stream.
|
||||
//
|
||||
// Printer aggressively enforces correct usage, crashing (with assert failures)
|
||||
// in the case of undefined variables in debug builds. This helps greatly in
|
||||
// debugging code which uses it.
|
||||
class LIBPROTOBUF_EXPORT Printer {
|
||||
public:
|
||||
// Create a printer that writes text to the given output stream. Use the
|
||||
// given character as the delimiter for variables.
|
||||
Printer(ZeroCopyOutputStream* output, char variable_delimiter);
|
||||
~Printer();
|
||||
|
||||
// Print some text after applying variable substitutions. If a particular
|
||||
// variable in the text is not defined, this will crash. Variables to be
|
||||
// substituted are identified by their names surrounded by delimiter
|
||||
// characters (as given to the constructor). The variable bindings are
|
||||
// defined by the given map.
|
||||
void Print(const map<string, string>& variables, const char* text);
|
||||
|
||||
// Like the first Print(), except the substitutions are given as parameters.
|
||||
void Print(const char* text);
|
||||
// Like the first Print(), except the substitutions are given as parameters.
|
||||
void Print(const char* text, const char* variable, const string& value);
|
||||
// Like the first Print(), except the substitutions are given as parameters.
|
||||
void Print(const char* text, const char* variable1, const string& value1,
|
||||
const char* variable2, const string& value2);
|
||||
// Like the first Print(), except the substitutions are given as parameters.
|
||||
void Print(const char* text, const char* variable1, const string& value1,
|
||||
const char* variable2, const string& value2,
|
||||
const char* variable3, const string& value3);
|
||||
// TODO(kenton): Overloaded versions with more variables? Three seems
|
||||
// to be enough.
|
||||
|
||||
// Indent text by two spaces. After calling Indent(), two spaces will be
|
||||
// inserted at the beginning of each line of text. Indent() may be called
|
||||
// multiple times to produce deeper indents.
|
||||
void Indent();
|
||||
|
||||
// Reduces the current indent level by two spaces, or crashes if the indent
|
||||
// level is zero.
|
||||
void Outdent();
|
||||
|
||||
// Write a string to the output buffer.
|
||||
// This method does not look for newlines to add indentation.
|
||||
void PrintRaw(const string& data);
|
||||
|
||||
// Write a zero-delimited string to output buffer.
|
||||
// This method does not look for newlines to add indentation.
|
||||
void PrintRaw(const char* data);
|
||||
|
||||
// Write some bytes to the output buffer.
|
||||
// This method does not look for newlines to add indentation.
|
||||
void WriteRaw(const char* data, int size);
|
||||
|
||||
// True if any write to the underlying stream failed. (We don't just
|
||||
// crash in this case because this is an I/O failure, not a programming
|
||||
// error.)
|
||||
bool failed() const { return failed_; }
|
||||
|
||||
private:
|
||||
const char variable_delimiter_;
|
||||
|
||||
ZeroCopyOutputStream* const output_;
|
||||
char* buffer_;
|
||||
int buffer_size_;
|
||||
|
||||
string indent_;
|
||||
bool at_start_of_line_;
|
||||
bool failed_;
|
||||
|
||||
GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(Printer);
|
||||
};
|
||||
|
||||
} // namespace io
|
||||
} // namespace protobuf
|
||||
|
||||
} // namespace google
|
||||
#endif // GOOGLE_PROTOBUF_IO_PRINTER_H__
|
||||
@ -1,694 +0,0 @@
|
||||
// Protocol Buffers - Google's data interchange format
|
||||
// Copyright 2008 Google Inc. All rights reserved.
|
||||
// http://code.google.com/p/protobuf/
|
||||
//
|
||||
// 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.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// 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.
|
||||
|
||||
// Author: kenton@google.com (Kenton Varda)
|
||||
// Based on original Protocol Buffers design by
|
||||
// Sanjay Ghemawat, Jeff Dean, and others.
|
||||
//
|
||||
// Here we have a hand-written lexer. At first you might ask yourself,
|
||||
// "Hand-written text processing? Is Kenton crazy?!" Well, first of all,
|
||||
// yes I am crazy, but that's beside the point. There are actually reasons
|
||||
// why I ended up writing this this way.
|
||||
//
|
||||
// The traditional approach to lexing is to use lex to generate a lexer for
|
||||
// you. Unfortunately, lex's output is ridiculously ugly and difficult to
|
||||
// integrate cleanly with C++ code, especially abstract code or code meant
|
||||
// as a library. Better parser-generators exist but would add dependencies
|
||||
// which most users won't already have, which we'd like to avoid. (GNU flex
|
||||
// has a C++ output option, but it's still ridiculously ugly, non-abstract,
|
||||
// and not library-friendly.)
|
||||
//
|
||||
// The next approach that any good software engineer should look at is to
|
||||
// use regular expressions. And, indeed, I did. I have code which
|
||||
// implements this same class using regular expressions. It's about 200
|
||||
// lines shorter. However:
|
||||
// - Rather than error messages telling you "This string has an invalid
|
||||
// escape sequence at line 5, column 45", you get error messages like
|
||||
// "Parse error on line 5". Giving more precise errors requires adding
|
||||
// a lot of code that ends up basically as complex as the hand-coded
|
||||
// version anyway.
|
||||
// - The regular expression to match a string literal looks like this:
|
||||
// kString = new RE("(\"([^\"\\\\]|" // non-escaped
|
||||
// "\\\\[abfnrtv?\"'\\\\0-7]|" // normal escape
|
||||
// "\\\\x[0-9a-fA-F])*\"|" // hex escape
|
||||
// "\'([^\'\\\\]|" // Also support single-quotes.
|
||||
// "\\\\[abfnrtv?\"'\\\\0-7]|"
|
||||
// "\\\\x[0-9a-fA-F])*\')");
|
||||
// Verifying the correctness of this line noise is actually harder than
|
||||
// verifying the correctness of ConsumeString(), defined below. I'm not
|
||||
// even confident that the above is correct, after staring at it for some
|
||||
// time.
|
||||
// - PCRE is fast, but there's still more overhead involved than the code
|
||||
// below.
|
||||
// - Sadly, regular expressions are not part of the C standard library, so
|
||||
// using them would require depending on some other library. For the
|
||||
// open source release, this could be really annoying. Nobody likes
|
||||
// downloading one piece of software just to find that they need to
|
||||
// download something else to make it work, and in all likelihood
|
||||
// people downloading Protocol Buffers will already be doing so just
|
||||
// to make something else work. We could include a copy of PCRE with
|
||||
// our code, but that obligates us to keep it up-to-date and just seems
|
||||
// like a big waste just to save 200 lines of code.
|
||||
//
|
||||
// On a similar but unrelated note, I'm even scared to use ctype.h.
|
||||
// Apparently functions like isalpha() are locale-dependent. So, if we used
|
||||
// that, then if this code is being called from some program that doesn't
|
||||
// have its locale set to "C", it would behave strangely. We can't just set
|
||||
// the locale to "C" ourselves since we might break the calling program that
|
||||
// way, particularly if it is multi-threaded. WTF? Someone please let me
|
||||
// (Kenton) know if I'm missing something here...
|
||||
//
|
||||
// I'd love to hear about other alternatives, though, as this code isn't
|
||||
// exactly pretty.
|
||||
|
||||
#include <google/protobuf/io/tokenizer.h>
|
||||
#include <google/protobuf/io/zero_copy_stream.h>
|
||||
#include <google/protobuf/stubs/strutil.h>
|
||||
|
||||
namespace google {
|
||||
namespace protobuf {
|
||||
namespace io {
|
||||
namespace {
|
||||
|
||||
// As mentioned above, I don't trust ctype.h due to the presence of "locales".
|
||||
// So, I have written replacement functions here. Someone please smack me if
|
||||
// this is a bad idea or if there is some way around this.
|
||||
//
|
||||
// These "character classes" are designed to be used in template methods.
|
||||
// For instance, Tokenizer::ConsumeZeroOrMore<Whitespace>() will eat
|
||||
// whitespace.
|
||||
|
||||
// Note: No class is allowed to contain '\0', since this is used to mark end-
|
||||
// of-input and is handled specially.
|
||||
|
||||
#define CHARACTER_CLASS(NAME, EXPRESSION) \
|
||||
class NAME { \
|
||||
public: \
|
||||
static inline bool InClass(char c) { \
|
||||
return EXPRESSION; \
|
||||
} \
|
||||
}
|
||||
|
||||
CHARACTER_CLASS(Whitespace, c == ' ' || c == '\n' || c == '\t' ||
|
||||
c == '\r' || c == '\v' || c == '\f');
|
||||
|
||||
CHARACTER_CLASS(Unprintable, c < ' ' && c > '\0');
|
||||
|
||||
CHARACTER_CLASS(Digit, '0' <= c && c <= '9');
|
||||
CHARACTER_CLASS(OctalDigit, '0' <= c && c <= '7');
|
||||
CHARACTER_CLASS(HexDigit, ('0' <= c && c <= '9') ||
|
||||
('a' <= c && c <= 'f') ||
|
||||
('A' <= c && c <= 'F'));
|
||||
|
||||
CHARACTER_CLASS(Letter, ('a' <= c && c <= 'z') ||
|
||||
('A' <= c && c <= 'Z') ||
|
||||
(c == '_'));
|
||||
|
||||
CHARACTER_CLASS(Alphanumeric, ('a' <= c && c <= 'z') ||
|
||||
('A' <= c && c <= 'Z') ||
|
||||
('0' <= c && c <= '9') ||
|
||||
(c == '_'));
|
||||
|
||||
CHARACTER_CLASS(Escape, c == 'a' || c == 'b' || c == 'f' || c == 'n' ||
|
||||
c == 'r' || c == 't' || c == 'v' || c == '\\' ||
|
||||
c == '?' || c == '\'' || c == '\"');
|
||||
|
||||
#undef CHARACTER_CLASS
|
||||
|
||||
// Given a char, interpret it as a numeric digit and return its value.
|
||||
// This supports any number base up to 36.
|
||||
inline int DigitValue(char digit) {
|
||||
if ('0' <= digit && digit <= '9') return digit - '0';
|
||||
if ('a' <= digit && digit <= 'z') return digit - 'a' + 10;
|
||||
if ('A' <= digit && digit <= 'Z') return digit - 'A' + 10;
|
||||
return -1;
|
||||
}
|
||||
|
||||
// Inline because it's only used in one place.
|
||||
inline char TranslateEscape(char c) {
|
||||
switch (c) {
|
||||
case 'a': return '\a';
|
||||
case 'b': return '\b';
|
||||
case 'f': return '\f';
|
||||
case 'n': return '\n';
|
||||
case 'r': return '\r';
|
||||
case 't': return '\t';
|
||||
case 'v': return '\v';
|
||||
case '\\': return '\\';
|
||||
case '?': return '\?'; // Trigraphs = :(
|
||||
case '\'': return '\'';
|
||||
case '"': return '\"';
|
||||
|
||||
// We expect escape sequences to have been validated separately.
|
||||
default: return '?';
|
||||
}
|
||||
}
|
||||
|
||||
} // anonymous namespace
|
||||
|
||||
ErrorCollector::~ErrorCollector() {}
|
||||
|
||||
// ===================================================================
|
||||
|
||||
Tokenizer::Tokenizer(ZeroCopyInputStream* input,
|
||||
ErrorCollector* error_collector)
|
||||
: input_(input),
|
||||
error_collector_(error_collector),
|
||||
buffer_(NULL),
|
||||
buffer_size_(0),
|
||||
buffer_pos_(0),
|
||||
read_error_(false),
|
||||
line_(0),
|
||||
column_(0),
|
||||
token_start_(-1),
|
||||
allow_f_after_float_(false),
|
||||
comment_style_(CPP_COMMENT_STYLE) {
|
||||
|
||||
current_.line = 0;
|
||||
current_.column = 0;
|
||||
current_.end_column = 0;
|
||||
current_.type = TYPE_START;
|
||||
|
||||
Refresh();
|
||||
}
|
||||
|
||||
Tokenizer::~Tokenizer() {
|
||||
// If we had any buffer left unread, return it to the underlying stream
|
||||
// so that someone else can read it.
|
||||
if (buffer_size_ > buffer_pos_) {
|
||||
input_->BackUp(buffer_size_ - buffer_pos_);
|
||||
}
|
||||
}
|
||||
|
||||
// -------------------------------------------------------------------
|
||||
// Internal helpers.
|
||||
|
||||
void Tokenizer::NextChar() {
|
||||
// Update our line and column counters based on the character being
|
||||
// consumed.
|
||||
if (current_char_ == '\n') {
|
||||
++line_;
|
||||
column_ = 0;
|
||||
} else if (current_char_ == '\t') {
|
||||
column_ += kTabWidth - column_ % kTabWidth;
|
||||
} else {
|
||||
++column_;
|
||||
}
|
||||
|
||||
// Advance to the next character.
|
||||
++buffer_pos_;
|
||||
if (buffer_pos_ < buffer_size_) {
|
||||
current_char_ = buffer_[buffer_pos_];
|
||||
} else {
|
||||
Refresh();
|
||||
}
|
||||
}
|
||||
|
||||
void Tokenizer::Refresh() {
|
||||
if (read_error_) {
|
||||
current_char_ = '\0';
|
||||
return;
|
||||
}
|
||||
|
||||
// If we're in a token, append the rest of the buffer to it.
|
||||
if (token_start_ >= 0 && token_start_ < buffer_size_) {
|
||||
current_.text.append(buffer_ + token_start_, buffer_size_ - token_start_);
|
||||
token_start_ = 0;
|
||||
}
|
||||
|
||||
const void* data = NULL;
|
||||
buffer_ = NULL;
|
||||
buffer_pos_ = 0;
|
||||
do {
|
||||
if (!input_->Next(&data, &buffer_size_)) {
|
||||
// end of stream (or read error)
|
||||
buffer_size_ = 0;
|
||||
read_error_ = true;
|
||||
current_char_ = '\0';
|
||||
return;
|
||||
}
|
||||
} while (buffer_size_ == 0);
|
||||
|
||||
buffer_ = static_cast<const char*>(data);
|
||||
|
||||
current_char_ = buffer_[0];
|
||||
}
|
||||
|
||||
inline void Tokenizer::StartToken() {
|
||||
token_start_ = buffer_pos_;
|
||||
current_.type = TYPE_START; // Just for the sake of initializing it.
|
||||
current_.text.clear();
|
||||
current_.line = line_;
|
||||
current_.column = column_;
|
||||
}
|
||||
|
||||
inline void Tokenizer::EndToken() {
|
||||
// Note: The if() is necessary because some STL implementations crash when
|
||||
// you call string::append(NULL, 0), presumably because they are trying to
|
||||
// be helpful by detecting the NULL pointer, even though there's nothing
|
||||
// wrong with reading zero bytes from NULL.
|
||||
if (buffer_pos_ != token_start_) {
|
||||
current_.text.append(buffer_ + token_start_, buffer_pos_ - token_start_);
|
||||
}
|
||||
token_start_ = -1;
|
||||
current_.end_column = column_;
|
||||
}
|
||||
|
||||
// -------------------------------------------------------------------
|
||||
// Helper methods that consume characters.
|
||||
|
||||
template<typename CharacterClass>
|
||||
inline bool Tokenizer::LookingAt() {
|
||||
return CharacterClass::InClass(current_char_);
|
||||
}
|
||||
|
||||
template<typename CharacterClass>
|
||||
inline bool Tokenizer::TryConsumeOne() {
|
||||
if (CharacterClass::InClass(current_char_)) {
|
||||
NextChar();
|
||||
return true;
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
inline bool Tokenizer::TryConsume(char c) {
|
||||
if (current_char_ == c) {
|
||||
NextChar();
|
||||
return true;
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
template<typename CharacterClass>
|
||||
inline void Tokenizer::ConsumeZeroOrMore() {
|
||||
while (CharacterClass::InClass(current_char_)) {
|
||||
NextChar();
|
||||
}
|
||||
}
|
||||
|
||||
template<typename CharacterClass>
|
||||
inline void Tokenizer::ConsumeOneOrMore(const char* error) {
|
||||
if (!CharacterClass::InClass(current_char_)) {
|
||||
AddError(error);
|
||||
} else {
|
||||
do {
|
||||
NextChar();
|
||||
} while (CharacterClass::InClass(current_char_));
|
||||
}
|
||||
}
|
||||
|
||||
// -------------------------------------------------------------------
|
||||
// Methods that read whole patterns matching certain kinds of tokens
|
||||
// or comments.
|
||||
|
||||
void Tokenizer::ConsumeString(char delimiter) {
|
||||
while (true) {
|
||||
switch (current_char_) {
|
||||
case '\0':
|
||||
case '\n': {
|
||||
AddError("String literals cannot cross line boundaries.");
|
||||
return;
|
||||
}
|
||||
|
||||
case '\\': {
|
||||
// An escape sequence.
|
||||
NextChar();
|
||||
if (TryConsumeOne<Escape>()) {
|
||||
// Valid escape sequence.
|
||||
} else if (TryConsumeOne<OctalDigit>()) {
|
||||
// Possibly followed by two more octal digits, but these will
|
||||
// just be consumed by the main loop anyway so we don't need
|
||||
// to do so explicitly here.
|
||||
} else if (TryConsume('x') || TryConsume('X')) {
|
||||
if (!TryConsumeOne<HexDigit>()) {
|
||||
AddError("Expected hex digits for escape sequence.");
|
||||
}
|
||||
// Possibly followed by another hex digit, but again we don't care.
|
||||
} else {
|
||||
AddError("Invalid escape sequence in string literal.");
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
default: {
|
||||
if (current_char_ == delimiter) {
|
||||
NextChar();
|
||||
return;
|
||||
}
|
||||
NextChar();
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Tokenizer::TokenType Tokenizer::ConsumeNumber(bool started_with_zero,
|
||||
bool started_with_dot) {
|
||||
bool is_float = false;
|
||||
|
||||
if (started_with_zero && (TryConsume('x') || TryConsume('X'))) {
|
||||
// A hex number (started with "0x").
|
||||
ConsumeOneOrMore<HexDigit>("\"0x\" must be followed by hex digits.");
|
||||
|
||||
} else if (started_with_zero && LookingAt<Digit>()) {
|
||||
// An octal number (had a leading zero).
|
||||
ConsumeZeroOrMore<OctalDigit>();
|
||||
if (LookingAt<Digit>()) {
|
||||
AddError("Numbers starting with leading zero must be in octal.");
|
||||
ConsumeZeroOrMore<Digit>();
|
||||
}
|
||||
|
||||
} else {
|
||||
// A decimal number.
|
||||
if (started_with_dot) {
|
||||
is_float = true;
|
||||
ConsumeZeroOrMore<Digit>();
|
||||
} else {
|
||||
ConsumeZeroOrMore<Digit>();
|
||||
|
||||
if (TryConsume('.')) {
|
||||
is_float = true;
|
||||
ConsumeZeroOrMore<Digit>();
|
||||
}
|
||||
}
|
||||
|
||||
if (TryConsume('e') || TryConsume('E')) {
|
||||
is_float = true;
|
||||
TryConsume('-') || TryConsume('+');
|
||||
ConsumeOneOrMore<Digit>("\"e\" must be followed by exponent.");
|
||||
}
|
||||
|
||||
if (allow_f_after_float_ && (TryConsume('f') || TryConsume('F'))) {
|
||||
is_float = true;
|
||||
}
|
||||
}
|
||||
|
||||
if (LookingAt<Letter>()) {
|
||||
AddError("Need space between number and identifier.");
|
||||
} else if (current_char_ == '.') {
|
||||
if (is_float) {
|
||||
AddError(
|
||||
"Already saw decimal point or exponent; can't have another one.");
|
||||
} else {
|
||||
AddError("Hex and octal numbers must be integers.");
|
||||
}
|
||||
}
|
||||
|
||||
return is_float ? TYPE_FLOAT : TYPE_INTEGER;
|
||||
}
|
||||
|
||||
void Tokenizer::ConsumeLineComment() {
|
||||
while (current_char_ != '\0' && current_char_ != '\n') {
|
||||
NextChar();
|
||||
}
|
||||
TryConsume('\n');
|
||||
}
|
||||
|
||||
void Tokenizer::ConsumeBlockComment() {
|
||||
int start_line = line_;
|
||||
int start_column = column_ - 2;
|
||||
|
||||
while (true) {
|
||||
while (current_char_ != '\0' &&
|
||||
current_char_ != '*' &&
|
||||
current_char_ != '/') {
|
||||
NextChar();
|
||||
}
|
||||
|
||||
if (TryConsume('*') && TryConsume('/')) {
|
||||
// End of comment.
|
||||
break;
|
||||
} else if (TryConsume('/') && current_char_ == '*') {
|
||||
// Note: We didn't consume the '*' because if there is a '/' after it
|
||||
// we want to interpret that as the end of the comment.
|
||||
AddError(
|
||||
"\"/*\" inside block comment. Block comments cannot be nested.");
|
||||
} else if (current_char_ == '\0') {
|
||||
AddError("End-of-file inside block comment.");
|
||||
error_collector_->AddError(
|
||||
start_line, start_column, " Comment started here.");
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// -------------------------------------------------------------------
|
||||
|
||||
bool Tokenizer::Next() {
|
||||
previous_ = current_;
|
||||
|
||||
// Did we skip any characters after the last token?
|
||||
bool skipped_stuff = false;
|
||||
|
||||
while (!read_error_) {
|
||||
if (TryConsumeOne<Whitespace>()) {
|
||||
ConsumeZeroOrMore<Whitespace>();
|
||||
|
||||
} else if (comment_style_ == CPP_COMMENT_STYLE && TryConsume('/')) {
|
||||
// Starting a comment?
|
||||
if (TryConsume('/')) {
|
||||
ConsumeLineComment();
|
||||
} else if (TryConsume('*')) {
|
||||
ConsumeBlockComment();
|
||||
} else {
|
||||
// Oops, it was just a slash. Return it.
|
||||
current_.type = TYPE_SYMBOL;
|
||||
current_.text = "/";
|
||||
current_.line = line_;
|
||||
current_.column = column_ - 1;
|
||||
return true;
|
||||
}
|
||||
|
||||
} else if (comment_style_ == SH_COMMENT_STYLE && TryConsume('#')) {
|
||||
ConsumeLineComment();
|
||||
|
||||
} else if (LookingAt<Unprintable>() || current_char_ == '\0') {
|
||||
AddError("Invalid control characters encountered in text.");
|
||||
NextChar();
|
||||
// Skip more unprintable characters, too. But, remember that '\0' is
|
||||
// also what current_char_ is set to after EOF / read error. We have
|
||||
// to be careful not to go into an infinite loop of trying to consume
|
||||
// it, so make sure to check read_error_ explicitly before consuming
|
||||
// '\0'.
|
||||
while (TryConsumeOne<Unprintable>() ||
|
||||
(!read_error_ && TryConsume('\0'))) {
|
||||
// Ignore.
|
||||
}
|
||||
|
||||
} else {
|
||||
// Reading some sort of token.
|
||||
StartToken();
|
||||
|
||||
if (TryConsumeOne<Letter>()) {
|
||||
ConsumeZeroOrMore<Alphanumeric>();
|
||||
current_.type = TYPE_IDENTIFIER;
|
||||
} else if (TryConsume('0')) {
|
||||
current_.type = ConsumeNumber(true, false);
|
||||
} else if (TryConsume('.')) {
|
||||
// This could be the beginning of a floating-point number, or it could
|
||||
// just be a '.' symbol.
|
||||
|
||||
if (TryConsumeOne<Digit>()) {
|
||||
// It's a floating-point number.
|
||||
if (previous_.type == TYPE_IDENTIFIER && !skipped_stuff) {
|
||||
// We don't accept syntax like "blah.123".
|
||||
error_collector_->AddError(line_, column_ - 2,
|
||||
"Need space between identifier and decimal point.");
|
||||
}
|
||||
current_.type = ConsumeNumber(false, true);
|
||||
} else {
|
||||
current_.type = TYPE_SYMBOL;
|
||||
}
|
||||
} else if (TryConsumeOne<Digit>()) {
|
||||
current_.type = ConsumeNumber(false, false);
|
||||
} else if (TryConsume('\"')) {
|
||||
ConsumeString('\"');
|
||||
current_.type = TYPE_STRING;
|
||||
} else if (TryConsume('\'')) {
|
||||
ConsumeString('\'');
|
||||
current_.type = TYPE_STRING;
|
||||
} else {
|
||||
NextChar();
|
||||
current_.type = TYPE_SYMBOL;
|
||||
}
|
||||
|
||||
EndToken();
|
||||
return true;
|
||||
}
|
||||
|
||||
skipped_stuff = true;
|
||||
}
|
||||
|
||||
// EOF
|
||||
current_.type = TYPE_END;
|
||||
current_.text.clear();
|
||||
current_.line = line_;
|
||||
current_.column = column_;
|
||||
current_.end_column = column_;
|
||||
return false;
|
||||
}
|
||||
|
||||
// -------------------------------------------------------------------
|
||||
// Token-parsing helpers. Remember that these don't need to report
|
||||
// errors since any errors should already have been reported while
|
||||
// tokenizing. Also, these can assume that whatever text they
|
||||
// are given is text that the tokenizer actually parsed as a token
|
||||
// of the given type.
|
||||
|
||||
bool Tokenizer::ParseInteger(const string& text, uint64 max_value,
|
||||
uint64* output) {
|
||||
// Sadly, we can't just use strtoul() since it is only 32-bit and strtoull()
|
||||
// is non-standard. I hate the C standard library. :(
|
||||
|
||||
// return strtoull(text.c_str(), NULL, 0);
|
||||
|
||||
const char* ptr = text.c_str();
|
||||
int base = 10;
|
||||
if (ptr[0] == '0') {
|
||||
if (ptr[1] == 'x' || ptr[1] == 'X') {
|
||||
// This is hex.
|
||||
base = 16;
|
||||
ptr += 2;
|
||||
} else {
|
||||
// This is octal.
|
||||
base = 8;
|
||||
}
|
||||
}
|
||||
|
||||
uint64 result = 0;
|
||||
for (; *ptr != '\0'; ptr++) {
|
||||
int digit = DigitValue(*ptr);
|
||||
GOOGLE_LOG_IF(DFATAL, digit < 0 || digit >= base)
|
||||
<< " Tokenizer::ParseInteger() passed text that could not have been"
|
||||
" tokenized as an integer: " << CEscape(text);
|
||||
if (digit > max_value || result > (max_value - digit) / base) {
|
||||
// Overflow.
|
||||
return false;
|
||||
}
|
||||
result = result * base + digit;
|
||||
}
|
||||
|
||||
*output = result;
|
||||
return true;
|
||||
}
|
||||
|
||||
double Tokenizer::ParseFloat(const string& text) {
|
||||
const char* start = text.c_str();
|
||||
char* end;
|
||||
double result = NoLocaleStrtod(start, &end);
|
||||
|
||||
// "1e" is not a valid float, but if the tokenizer reads it, it will
|
||||
// report an error but still return it as a valid token. We need to
|
||||
// accept anything the tokenizer could possibly return, error or not.
|
||||
if (*end == 'e' || *end == 'E') {
|
||||
++end;
|
||||
if (*end == '-' || *end == '+') ++end;
|
||||
}
|
||||
|
||||
// If the Tokenizer had allow_f_after_float_ enabled, the float may be
|
||||
// suffixed with the letter 'f'.
|
||||
if (*end == 'f' || *end == 'F') {
|
||||
++end;
|
||||
}
|
||||
|
||||
GOOGLE_LOG_IF(DFATAL, end - start != text.size() || *start == '-')
|
||||
<< " Tokenizer::ParseFloat() passed text that could not have been"
|
||||
" tokenized as a float: " << CEscape(text);
|
||||
return result;
|
||||
}
|
||||
|
||||
void Tokenizer::ParseStringAppend(const string& text, string* output) {
|
||||
// Reminder: text[0] is always the quote character. (If text is
|
||||
// empty, it's invalid, so we'll just return.)
|
||||
if (text.empty()) {
|
||||
GOOGLE_LOG(DFATAL)
|
||||
<< " Tokenizer::ParseStringAppend() passed text that could not"
|
||||
" have been tokenized as a string: " << CEscape(text);
|
||||
return;
|
||||
}
|
||||
|
||||
output->reserve(output->size() + text.size());
|
||||
|
||||
// Loop through the string copying characters to "output" and
|
||||
// interpreting escape sequences. Note that any invalid escape
|
||||
// sequences or other errors were already reported while tokenizing.
|
||||
// In this case we do not need to produce valid results.
|
||||
for (const char* ptr = text.c_str() + 1; *ptr != '\0'; ptr++) {
|
||||
if (*ptr == '\\' && ptr[1] != '\0') {
|
||||
// An escape sequence.
|
||||
++ptr;
|
||||
|
||||
if (OctalDigit::InClass(*ptr)) {
|
||||
// An octal escape. May one, two, or three digits.
|
||||
int code = DigitValue(*ptr);
|
||||
if (OctalDigit::InClass(ptr[1])) {
|
||||
++ptr;
|
||||
code = code * 8 + DigitValue(*ptr);
|
||||
}
|
||||
if (OctalDigit::InClass(ptr[1])) {
|
||||
++ptr;
|
||||
code = code * 8 + DigitValue(*ptr);
|
||||
}
|
||||
output->push_back(static_cast<char>(code));
|
||||
|
||||
} else if (*ptr == 'x') {
|
||||
// A hex escape. May zero, one, or two digits. (The zero case
|
||||
// will have been caught as an error earlier.)
|
||||
int code = 0;
|
||||
if (HexDigit::InClass(ptr[1])) {
|
||||
++ptr;
|
||||
code = DigitValue(*ptr);
|
||||
}
|
||||
if (HexDigit::InClass(ptr[1])) {
|
||||
++ptr;
|
||||
code = code * 16 + DigitValue(*ptr);
|
||||
}
|
||||
output->push_back(static_cast<char>(code));
|
||||
|
||||
} else {
|
||||
// Some other escape code.
|
||||
output->push_back(TranslateEscape(*ptr));
|
||||
}
|
||||
|
||||
} else if (*ptr == text[0]) {
|
||||
// Ignore quote matching the starting quote.
|
||||
} else {
|
||||
output->push_back(*ptr);
|
||||
}
|
||||
}
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
} // namespace io
|
||||
} // namespace protobuf
|
||||
} // namespace google
|
||||
@ -1,319 +0,0 @@
|
||||
// Protocol Buffers - Google's data interchange format
|
||||
// Copyright 2008 Google Inc. All rights reserved.
|
||||
// http://code.google.com/p/protobuf/
|
||||
//
|
||||
// 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.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// 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.
|
||||
|
||||
// Author: kenton@google.com (Kenton Varda)
|
||||
// Based on original Protocol Buffers design by
|
||||
// Sanjay Ghemawat, Jeff Dean, and others.
|
||||
|
||||
#include <fstream>
|
||||
#include <stack>
|
||||
#include <google/protobuf/stubs/hash.h>
|
||||
|
||||
#include <google/protobuf/message.h>
|
||||
|
||||
#include <google/protobuf/stubs/common.h>
|
||||
#include <google/protobuf/stubs/once.h>
|
||||
#include <google/protobuf/io/coded_stream.h>
|
||||
#include <google/protobuf/io/zero_copy_stream_impl.h>
|
||||
#include <google/protobuf/descriptor.pb.h>
|
||||
#include <google/protobuf/descriptor.h>
|
||||
#include <google/protobuf/reflection_ops.h>
|
||||
#include <google/protobuf/wire_format.h>
|
||||
#include <google/protobuf/stubs/strutil.h>
|
||||
#include <google/protobuf/stubs/map-util.h>
|
||||
#include <google/protobuf/stubs/stl_util-inl.h>
|
||||
|
||||
namespace google {
|
||||
namespace protobuf {
|
||||
|
||||
using internal::WireFormat;
|
||||
using internal::ReflectionOps;
|
||||
|
||||
Message::~Message() {}
|
||||
|
||||
void Message::MergeFrom(const Message& from) {
|
||||
const Descriptor* descriptor = GetDescriptor();
|
||||
GOOGLE_CHECK_EQ(from.GetDescriptor(), descriptor)
|
||||
<< ": Tried to merge from a message with a different type. "
|
||||
"to: " << descriptor->full_name() << ", "
|
||||
"from:" << from.GetDescriptor()->full_name();
|
||||
ReflectionOps::Merge(from, this);
|
||||
}
|
||||
|
||||
void Message::CheckTypeAndMergeFrom(const MessageLite& other) {
|
||||
MergeFrom(*down_cast<const Message*>(&other));
|
||||
}
|
||||
|
||||
void Message::CopyFrom(const Message& from) {
|
||||
const Descriptor* descriptor = GetDescriptor();
|
||||
GOOGLE_CHECK_EQ(from.GetDescriptor(), descriptor)
|
||||
<< ": Tried to copy from a message with a different type."
|
||||
"to: " << descriptor->full_name() << ", "
|
||||
"from:" << from.GetDescriptor()->full_name();
|
||||
ReflectionOps::Copy(from, this);
|
||||
}
|
||||
|
||||
string Message::GetTypeName() const {
|
||||
return GetDescriptor()->full_name();
|
||||
}
|
||||
|
||||
void Message::Clear() {
|
||||
ReflectionOps::Clear(this);
|
||||
}
|
||||
|
||||
bool Message::IsInitialized() const {
|
||||
return ReflectionOps::IsInitialized(*this);
|
||||
}
|
||||
|
||||
void Message::FindInitializationErrors(vector<string>* errors) const {
|
||||
return ReflectionOps::FindInitializationErrors(*this, "", errors);
|
||||
}
|
||||
|
||||
string Message::InitializationErrorString() const {
|
||||
vector<string> errors;
|
||||
FindInitializationErrors(&errors);
|
||||
return JoinStrings(errors, ", ");
|
||||
}
|
||||
|
||||
void Message::CheckInitialized() const {
|
||||
GOOGLE_CHECK(IsInitialized())
|
||||
<< "Message of type \"" << GetDescriptor()->full_name()
|
||||
<< "\" is missing required fields: " << InitializationErrorString();
|
||||
}
|
||||
|
||||
void Message::DiscardUnknownFields() {
|
||||
return ReflectionOps::DiscardUnknownFields(this);
|
||||
}
|
||||
|
||||
bool Message::MergePartialFromCodedStream(io::CodedInputStream* input) {
|
||||
return WireFormat::ParseAndMergePartial(input, this);
|
||||
}
|
||||
|
||||
bool Message::ParseFromFileDescriptor(int file_descriptor) {
|
||||
io::FileInputStream input(file_descriptor);
|
||||
return ParseFromZeroCopyStream(&input) && input.GetErrno() == 0;
|
||||
}
|
||||
|
||||
bool Message::ParsePartialFromFileDescriptor(int file_descriptor) {
|
||||
io::FileInputStream input(file_descriptor);
|
||||
return ParsePartialFromZeroCopyStream(&input) && input.GetErrno() == 0;
|
||||
}
|
||||
|
||||
bool Message::ParseFromIstream(istream* input) {
|
||||
io::IstreamInputStream zero_copy_input(input);
|
||||
return ParseFromZeroCopyStream(&zero_copy_input) && input->eof();
|
||||
}
|
||||
|
||||
bool Message::ParsePartialFromIstream(istream* input) {
|
||||
io::IstreamInputStream zero_copy_input(input);
|
||||
return ParsePartialFromZeroCopyStream(&zero_copy_input) && input->eof();
|
||||
}
|
||||
|
||||
|
||||
void Message::SerializeWithCachedSizes(
|
||||
io::CodedOutputStream* output) const {
|
||||
WireFormat::SerializeWithCachedSizes(*this, GetCachedSize(), output);
|
||||
}
|
||||
|
||||
int Message::ByteSize() const {
|
||||
int size = WireFormat::ByteSize(*this);
|
||||
SetCachedSize(size);
|
||||
return size;
|
||||
}
|
||||
|
||||
void Message::SetCachedSize(int size) const {
|
||||
GOOGLE_LOG(FATAL) << "Message class \"" << GetDescriptor()->full_name()
|
||||
<< "\" implements neither SetCachedSize() nor ByteSize(). "
|
||||
"Must implement one or the other.";
|
||||
}
|
||||
|
||||
int Message::SpaceUsed() const {
|
||||
return GetReflection()->SpaceUsed(*this);
|
||||
}
|
||||
|
||||
bool Message::SerializeToFileDescriptor(int file_descriptor) const {
|
||||
io::FileOutputStream output(file_descriptor);
|
||||
return SerializeToZeroCopyStream(&output);
|
||||
}
|
||||
|
||||
bool Message::SerializePartialToFileDescriptor(int file_descriptor) const {
|
||||
io::FileOutputStream output(file_descriptor);
|
||||
return SerializePartialToZeroCopyStream(&output);
|
||||
}
|
||||
|
||||
bool Message::SerializeToOstream(ostream* output) const {
|
||||
{
|
||||
io::OstreamOutputStream zero_copy_output(output);
|
||||
if (!SerializeToZeroCopyStream(&zero_copy_output)) return false;
|
||||
}
|
||||
return output->good();
|
||||
}
|
||||
|
||||
bool Message::SerializePartialToOstream(ostream* output) const {
|
||||
io::OstreamOutputStream zero_copy_output(output);
|
||||
return SerializePartialToZeroCopyStream(&zero_copy_output);
|
||||
}
|
||||
|
||||
|
||||
Reflection::~Reflection() {}
|
||||
|
||||
// ===================================================================
|
||||
// MessageFactory
|
||||
|
||||
MessageFactory::~MessageFactory() {}
|
||||
|
||||
namespace {
|
||||
|
||||
class GeneratedMessageFactory : public MessageFactory {
|
||||
public:
|
||||
GeneratedMessageFactory();
|
||||
~GeneratedMessageFactory();
|
||||
|
||||
static GeneratedMessageFactory* singleton();
|
||||
|
||||
typedef void RegistrationFunc(const string&);
|
||||
void RegisterFile(const char* file, RegistrationFunc* registration_func);
|
||||
void RegisterType(const Descriptor* descriptor, const Message* prototype);
|
||||
|
||||
// implements MessageFactory ---------------------------------------
|
||||
const Message* GetPrototype(const Descriptor* type);
|
||||
|
||||
private:
|
||||
// Only written at static init time, so does not require locking.
|
||||
hash_map<const char*, RegistrationFunc*,
|
||||
hash<const char*>, streq> file_map_;
|
||||
|
||||
// Initialized lazily, so requires locking.
|
||||
Mutex mutex_;
|
||||
hash_map<const Descriptor*, const Message*> type_map_;
|
||||
};
|
||||
|
||||
GeneratedMessageFactory* generated_message_factory_ = NULL;
|
||||
GOOGLE_PROTOBUF_DECLARE_ONCE(generated_message_factory_once_init_);
|
||||
|
||||
void ShutdownGeneratedMessageFactory() {
|
||||
delete generated_message_factory_;
|
||||
}
|
||||
|
||||
void InitGeneratedMessageFactory() {
|
||||
generated_message_factory_ = new GeneratedMessageFactory;
|
||||
internal::OnShutdown(&ShutdownGeneratedMessageFactory);
|
||||
}
|
||||
|
||||
GeneratedMessageFactory::GeneratedMessageFactory() {}
|
||||
GeneratedMessageFactory::~GeneratedMessageFactory() {}
|
||||
|
||||
GeneratedMessageFactory* GeneratedMessageFactory::singleton() {
|
||||
::google::protobuf::GoogleOnceInit(&generated_message_factory_once_init_,
|
||||
&InitGeneratedMessageFactory);
|
||||
return generated_message_factory_;
|
||||
}
|
||||
|
||||
void GeneratedMessageFactory::RegisterFile(
|
||||
const char* file, RegistrationFunc* registration_func) {
|
||||
if (!InsertIfNotPresent(&file_map_, file, registration_func)) {
|
||||
GOOGLE_LOG(FATAL) << "File is already registered: " << file;
|
||||
}
|
||||
}
|
||||
|
||||
void GeneratedMessageFactory::RegisterType(const Descriptor* descriptor,
|
||||
const Message* prototype) {
|
||||
GOOGLE_DCHECK_EQ(descriptor->file()->pool(), DescriptorPool::generated_pool())
|
||||
<< "Tried to register a non-generated type with the generated "
|
||||
"type registry.";
|
||||
|
||||
// This should only be called as a result of calling a file registration
|
||||
// function during GetPrototype(), in which case we already have locked
|
||||
// the mutex.
|
||||
mutex_.AssertHeld();
|
||||
if (!InsertIfNotPresent(&type_map_, descriptor, prototype)) {
|
||||
GOOGLE_LOG(DFATAL) << "Type is already registered: " << descriptor->full_name();
|
||||
}
|
||||
}
|
||||
|
||||
const Message* GeneratedMessageFactory::GetPrototype(const Descriptor* type) {
|
||||
{
|
||||
ReaderMutexLock lock(&mutex_);
|
||||
const Message* result = FindPtrOrNull(type_map_, type);
|
||||
if (result != NULL) return result;
|
||||
}
|
||||
|
||||
// If the type is not in the generated pool, then we can't possibly handle
|
||||
// it.
|
||||
if (type->file()->pool() != DescriptorPool::generated_pool()) return NULL;
|
||||
|
||||
// Apparently the file hasn't been registered yet. Let's do that now.
|
||||
RegistrationFunc* registration_func =
|
||||
FindPtrOrNull(file_map_, type->file()->name().c_str());
|
||||
if (registration_func == NULL) {
|
||||
GOOGLE_LOG(DFATAL) << "File appears to be in generated pool but wasn't "
|
||||
"registered: " << type->file()->name();
|
||||
return NULL;
|
||||
}
|
||||
|
||||
WriterMutexLock lock(&mutex_);
|
||||
|
||||
// Check if another thread preempted us.
|
||||
const Message* result = FindPtrOrNull(type_map_, type);
|
||||
if (result == NULL) {
|
||||
// Nope. OK, register everything.
|
||||
registration_func(type->file()->name());
|
||||
// Should be here now.
|
||||
result = FindPtrOrNull(type_map_, type);
|
||||
}
|
||||
|
||||
if (result == NULL) {
|
||||
GOOGLE_LOG(DFATAL) << "Type appears to be in generated pool but wasn't "
|
||||
<< "registered: " << type->full_name();
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
} // namespace
|
||||
|
||||
MessageFactory* MessageFactory::generated_factory() {
|
||||
return GeneratedMessageFactory::singleton();
|
||||
}
|
||||
|
||||
void MessageFactory::InternalRegisterGeneratedFile(
|
||||
const char* filename, void (*register_messages)(const string&)) {
|
||||
GeneratedMessageFactory::singleton()->RegisterFile(filename,
|
||||
register_messages);
|
||||
}
|
||||
|
||||
void MessageFactory::InternalRegisterGeneratedMessage(
|
||||
const Descriptor* descriptor, const Message* prototype) {
|
||||
GeneratedMessageFactory::singleton()->RegisterType(descriptor, prototype);
|
||||
}
|
||||
|
||||
|
||||
} // namespace protobuf
|
||||
} // namespace google
|
||||
@ -1,692 +0,0 @@
|
||||
// Protocol Buffers - Google's data interchange format
|
||||
// Copyright 2008 Google Inc. All rights reserved.
|
||||
// http://code.google.com/p/protobuf/
|
||||
//
|
||||
// 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.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// 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.
|
||||
|
||||
// Author: kenton@google.com (Kenton Varda)
|
||||
// Based on original Protocol Buffers design by
|
||||
// Sanjay Ghemawat, Jeff Dean, and others.
|
||||
//
|
||||
// Defines Message, the abstract interface implemented by non-lite
|
||||
// protocol message objects. Although it's possible to implement this
|
||||
// interface manually, most users will use the protocol compiler to
|
||||
// generate implementations.
|
||||
//
|
||||
// Example usage:
|
||||
//
|
||||
// Say you have a message defined as:
|
||||
//
|
||||
// message Foo {
|
||||
// optional string text = 1;
|
||||
// repeated int32 numbers = 2;
|
||||
// }
|
||||
//
|
||||
// Then, if you used the protocol compiler to generate a class from the above
|
||||
// definition, you could use it like so:
|
||||
//
|
||||
// string data; // Will store a serialized version of the message.
|
||||
//
|
||||
// {
|
||||
// // Create a message and serialize it.
|
||||
// Foo foo;
|
||||
// foo.set_text("Hello World!");
|
||||
// foo.add_numbers(1);
|
||||
// foo.add_numbers(5);
|
||||
// foo.add_numbers(42);
|
||||
//
|
||||
// foo.SerializeToString(&data);
|
||||
// }
|
||||
//
|
||||
// {
|
||||
// // Parse the serialized message and check that it contains the
|
||||
// // correct data.
|
||||
// Foo foo;
|
||||
// foo.ParseFromString(data);
|
||||
//
|
||||
// assert(foo.text() == "Hello World!");
|
||||
// assert(foo.numbers_size() == 3);
|
||||
// assert(foo.numbers(0) == 1);
|
||||
// assert(foo.numbers(1) == 5);
|
||||
// assert(foo.numbers(2) == 42);
|
||||
// }
|
||||
//
|
||||
// {
|
||||
// // Same as the last block, but do it dynamically via the Message
|
||||
// // reflection interface.
|
||||
// Message* foo = new Foo;
|
||||
// Descriptor* descriptor = foo->GetDescriptor();
|
||||
//
|
||||
// // Get the descriptors for the fields we're interested in and verify
|
||||
// // their types.
|
||||
// FieldDescriptor* text_field = descriptor->FindFieldByName("text");
|
||||
// assert(text_field != NULL);
|
||||
// assert(text_field->type() == FieldDescriptor::TYPE_STRING);
|
||||
// assert(text_field->label() == FieldDescriptor::TYPE_OPTIONAL);
|
||||
// FieldDescriptor* numbers_field = descriptor->FindFieldByName("numbers");
|
||||
// assert(numbers_field != NULL);
|
||||
// assert(numbers_field->type() == FieldDescriptor::TYPE_INT32);
|
||||
// assert(numbers_field->label() == FieldDescriptor::TYPE_REPEATED);
|
||||
//
|
||||
// // Parse the message.
|
||||
// foo->ParseFromString(data);
|
||||
//
|
||||
// // Use the reflection interface to examine the contents.
|
||||
// const Reflection* reflection = foo->GetReflection();
|
||||
// assert(reflection->GetString(foo, text_field) == "Hello World!");
|
||||
// assert(reflection->FieldSize(foo, numbers_field) == 3);
|
||||
// assert(reflection->GetRepeatedInt32(foo, numbers_field, 0) == 1);
|
||||
// assert(reflection->GetRepeatedInt32(foo, numbers_field, 1) == 5);
|
||||
// assert(reflection->GetRepeatedInt32(foo, numbers_field, 2) == 42);
|
||||
//
|
||||
// delete foo;
|
||||
// }
|
||||
|
||||
#ifndef GOOGLE_PROTOBUF_MESSAGE_H__
|
||||
#define GOOGLE_PROTOBUF_MESSAGE_H__
|
||||
|
||||
#include <vector>
|
||||
#include <string>
|
||||
|
||||
#ifdef __DECCXX
|
||||
// HP C++'s iosfwd doesn't work.
|
||||
#include <iostream>
|
||||
#else
|
||||
#include <iosfwd>
|
||||
#endif
|
||||
|
||||
#include <google/protobuf/message_lite.h>
|
||||
|
||||
#include <google/protobuf/stubs/common.h>
|
||||
|
||||
|
||||
namespace google {
|
||||
namespace protobuf {
|
||||
|
||||
// Defined in this file.
|
||||
class Message;
|
||||
class Reflection;
|
||||
class MessageFactory;
|
||||
|
||||
// Defined in other files.
|
||||
class Descriptor; // descriptor.h
|
||||
class FieldDescriptor; // descriptor.h
|
||||
class EnumDescriptor; // descriptor.h
|
||||
class EnumValueDescriptor; // descriptor.h
|
||||
namespace io {
|
||||
class ZeroCopyInputStream; // zero_copy_stream.h
|
||||
class ZeroCopyOutputStream; // zero_copy_stream.h
|
||||
class CodedInputStream; // coded_stream.h
|
||||
class CodedOutputStream; // coded_stream.h
|
||||
}
|
||||
class UnknownFieldSet; // unknown_field_set.h
|
||||
|
||||
// A container to hold message metadata.
|
||||
struct Metadata {
|
||||
const Descriptor* descriptor;
|
||||
const Reflection* reflection;
|
||||
};
|
||||
|
||||
// Returns the EnumDescriptor for enum type E, which must be a
|
||||
// proto-declared enum type. Code generated by the protocol compiler
|
||||
// will include specializations of this template for each enum type declared.
|
||||
template <typename E>
|
||||
const EnumDescriptor* GetEnumDescriptor();
|
||||
|
||||
// Abstract interface for protocol messages.
|
||||
//
|
||||
// See also MessageLite, which contains most every-day operations. Message
|
||||
// adds descriptors and reflection on top of that.
|
||||
//
|
||||
// The methods of this class that are virtual but not pure-virtual have
|
||||
// default implementations based on reflection. Message classes which are
|
||||
// optimized for speed will want to override these with faster implementations,
|
||||
// but classes optimized for code size may be happy with keeping them. See
|
||||
// the optimize_for option in descriptor.proto.
|
||||
class LIBPROTOBUF_EXPORT Message : public MessageLite {
|
||||
public:
|
||||
inline Message() {}
|
||||
virtual ~Message();
|
||||
|
||||
// Basic Operations ------------------------------------------------
|
||||
|
||||
// Construct a new instance of the same type. Ownership is passed to the
|
||||
// caller. (This is also defined in MessageLite, but is defined again here
|
||||
// for return-type covariance.)
|
||||
virtual Message* New() const = 0;
|
||||
|
||||
// Make this message into a copy of the given message. The given message
|
||||
// must have the same descriptor, but need not necessarily be the same class.
|
||||
// By default this is just implemented as "Clear(); MergeFrom(from);".
|
||||
virtual void CopyFrom(const Message& from);
|
||||
|
||||
// Merge the fields from the given message into this message. Singular
|
||||
// fields will be overwritten, except for embedded messages which will
|
||||
// be merged. Repeated fields will be concatenated. The given message
|
||||
// must be of the same type as this message (i.e. the exact same class).
|
||||
virtual void MergeFrom(const Message& from);
|
||||
|
||||
// Verifies that IsInitialized() returns true. GOOGLE_CHECK-fails otherwise, with
|
||||
// a nice error message.
|
||||
void CheckInitialized() const;
|
||||
|
||||
// Slowly build a list of all required fields that are not set.
|
||||
// This is much, much slower than IsInitialized() as it is implemented
|
||||
// purely via reflection. Generally, you should not call this unless you
|
||||
// have already determined that an error exists by calling IsInitialized().
|
||||
void FindInitializationErrors(vector<string>* errors) const;
|
||||
|
||||
// Like FindInitializationErrors, but joins all the strings, delimited by
|
||||
// commas, and returns them.
|
||||
string InitializationErrorString() const;
|
||||
|
||||
// Clears all unknown fields from this message and all embedded messages.
|
||||
// Normally, if unknown tag numbers are encountered when parsing a message,
|
||||
// the tag and value are stored in the message's UnknownFieldSet and
|
||||
// then written back out when the message is serialized. This allows servers
|
||||
// which simply route messages to other servers to pass through messages
|
||||
// that have new field definitions which they don't yet know about. However,
|
||||
// this behavior can have security implications. To avoid it, call this
|
||||
// method after parsing.
|
||||
//
|
||||
// See Reflection::GetUnknownFields() for more on unknown fields.
|
||||
virtual void DiscardUnknownFields();
|
||||
|
||||
// Computes (an estimate of) the total number of bytes currently used for
|
||||
// storing the message in memory. The default implementation calls the
|
||||
// Reflection object's SpaceUsed() method.
|
||||
virtual int SpaceUsed() const;
|
||||
|
||||
// Debugging & Testing----------------------------------------------
|
||||
|
||||
// Generates a human readable form of this message, useful for debugging
|
||||
// and other purposes.
|
||||
string DebugString() const;
|
||||
// Like DebugString(), but with less whitespace.
|
||||
string ShortDebugString() const;
|
||||
// Like DebugString(), but do not escape UTF-8 byte sequences.
|
||||
string Utf8DebugString() const;
|
||||
// Convenience function useful in GDB. Prints DebugString() to stdout.
|
||||
void PrintDebugString() const;
|
||||
|
||||
// Heavy I/O -------------------------------------------------------
|
||||
// Additional parsing and serialization methods not implemented by
|
||||
// MessageLite because they are not supported by the lite library.
|
||||
|
||||
// Parse a protocol buffer from a file descriptor. If successful, the entire
|
||||
// input will be consumed.
|
||||
bool ParseFromFileDescriptor(int file_descriptor);
|
||||
// Like ParseFromFileDescriptor(), but accepts messages that are missing
|
||||
// required fields.
|
||||
bool ParsePartialFromFileDescriptor(int file_descriptor);
|
||||
// Parse a protocol buffer from a C++ istream. If successful, the entire
|
||||
// input will be consumed.
|
||||
bool ParseFromIstream(istream* input);
|
||||
// Like ParseFromIstream(), but accepts messages that are missing
|
||||
// required fields.
|
||||
bool ParsePartialFromIstream(istream* input);
|
||||
|
||||
// Serialize the message and write it to the given file descriptor. All
|
||||
// required fields must be set.
|
||||
bool SerializeToFileDescriptor(int file_descriptor) const;
|
||||
// Like SerializeToFileDescriptor(), but allows missing required fields.
|
||||
bool SerializePartialToFileDescriptor(int file_descriptor) const;
|
||||
// Serialize the message and write it to the given C++ ostream. All
|
||||
// required fields must be set.
|
||||
bool SerializeToOstream(ostream* output) const;
|
||||
// Like SerializeToOstream(), but allows missing required fields.
|
||||
bool SerializePartialToOstream(ostream* output) const;
|
||||
|
||||
|
||||
// Reflection-based methods ----------------------------------------
|
||||
// These methods are pure-virtual in MessageLite, but Message provides
|
||||
// reflection-based default implementations.
|
||||
|
||||
virtual string GetTypeName() const;
|
||||
virtual void Clear();
|
||||
virtual bool IsInitialized() const;
|
||||
virtual void CheckTypeAndMergeFrom(const MessageLite& other);
|
||||
virtual bool MergePartialFromCodedStream(io::CodedInputStream* input);
|
||||
virtual int ByteSize() const;
|
||||
virtual void SerializeWithCachedSizes(io::CodedOutputStream* output) const;
|
||||
|
||||
private:
|
||||
// This is called only by the default implementation of ByteSize(), to
|
||||
// update the cached size. If you override ByteSize(), you do not need
|
||||
// to override this. If you do not override ByteSize(), you MUST override
|
||||
// this; the default implementation will crash.
|
||||
//
|
||||
// The method is private because subclasses should never call it; only
|
||||
// override it. Yes, C++ lets you do that. Crazy, huh?
|
||||
virtual void SetCachedSize(int size) const;
|
||||
|
||||
public:
|
||||
|
||||
// Introspection ---------------------------------------------------
|
||||
|
||||
// Typedef for backwards-compatibility.
|
||||
typedef google::protobuf::Reflection Reflection;
|
||||
|
||||
// Get a Descriptor for this message's type. This describes what
|
||||
// fields the message contains, the types of those fields, etc.
|
||||
const Descriptor* GetDescriptor() const { return GetMetadata().descriptor; }
|
||||
|
||||
// Get the Reflection interface for this Message, which can be used to
|
||||
// read and modify the fields of the Message dynamically (in other words,
|
||||
// without knowing the message type at compile time). This object remains
|
||||
// property of the Message.
|
||||
//
|
||||
// This method remains virtual in case a subclass does not implement
|
||||
// reflection and wants to override the default behavior.
|
||||
virtual const Reflection* GetReflection() const {
|
||||
return GetMetadata().reflection;
|
||||
}
|
||||
|
||||
protected:
|
||||
// Get a struct containing the metadata for the Message. Most subclasses only
|
||||
// need to implement this method, rather than the GetDescriptor() and
|
||||
// GetReflection() wrappers.
|
||||
virtual Metadata GetMetadata() const = 0;
|
||||
|
||||
|
||||
private:
|
||||
GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(Message);
|
||||
};
|
||||
|
||||
// This interface contains methods that can be used to dynamically access
|
||||
// and modify the fields of a protocol message. Their semantics are
|
||||
// similar to the accessors the protocol compiler generates.
|
||||
//
|
||||
// To get the Reflection for a given Message, call Message::GetReflection().
|
||||
//
|
||||
// This interface is separate from Message only for efficiency reasons;
|
||||
// the vast majority of implementations of Message will share the same
|
||||
// implementation of Reflection (GeneratedMessageReflection,
|
||||
// defined in generated_message.h), and all Messages of a particular class
|
||||
// should share the same Reflection object (though you should not rely on
|
||||
// the latter fact).
|
||||
//
|
||||
// There are several ways that these methods can be used incorrectly. For
|
||||
// example, any of the following conditions will lead to undefined
|
||||
// results (probably assertion failures):
|
||||
// - The FieldDescriptor is not a field of this message type.
|
||||
// - The method called is not appropriate for the field's type. For
|
||||
// each field type in FieldDescriptor::TYPE_*, there is only one
|
||||
// Get*() method, one Set*() method, and one Add*() method that is
|
||||
// valid for that type. It should be obvious which (except maybe
|
||||
// for TYPE_BYTES, which are represented using strings in C++).
|
||||
// - A Get*() or Set*() method for singular fields is called on a repeated
|
||||
// field.
|
||||
// - GetRepeated*(), SetRepeated*(), or Add*() is called on a non-repeated
|
||||
// field.
|
||||
// - The Message object passed to any method is not of the right type for
|
||||
// this Reflection object (i.e. message.GetReflection() != reflection).
|
||||
//
|
||||
// You might wonder why there is not any abstract representation for a field
|
||||
// of arbitrary type. E.g., why isn't there just a "GetField()" method that
|
||||
// returns "const Field&", where "Field" is some class with accessors like
|
||||
// "GetInt32Value()". The problem is that someone would have to deal with
|
||||
// allocating these Field objects. For generated message classes, having to
|
||||
// allocate space for an additional object to wrap every field would at least
|
||||
// double the message's memory footprint, probably worse. Allocating the
|
||||
// objects on-demand, on the other hand, would be expensive and prone to
|
||||
// memory leaks. So, instead we ended up with this flat interface.
|
||||
//
|
||||
// TODO(kenton): Create a utility class which callers can use to read and
|
||||
// write fields from a Reflection without paying attention to the type.
|
||||
class LIBPROTOBUF_EXPORT Reflection {
|
||||
public:
|
||||
// TODO(kenton): Remove parameter.
|
||||
inline Reflection() {}
|
||||
virtual ~Reflection();
|
||||
|
||||
// Get the UnknownFieldSet for the message. This contains fields which
|
||||
// were seen when the Message was parsed but were not recognized according
|
||||
// to the Message's definition.
|
||||
virtual const UnknownFieldSet& GetUnknownFields(
|
||||
const Message& message) const = 0;
|
||||
// Get a mutable pointer to the UnknownFieldSet for the message. This
|
||||
// contains fields which were seen when the Message was parsed but were not
|
||||
// recognized according to the Message's definition.
|
||||
virtual UnknownFieldSet* MutableUnknownFields(Message* message) const = 0;
|
||||
|
||||
// Estimate the amount of memory used by the message object.
|
||||
virtual int SpaceUsed(const Message& message) const = 0;
|
||||
|
||||
// Check if the given non-repeated field is set.
|
||||
virtual bool HasField(const Message& message,
|
||||
const FieldDescriptor* field) const = 0;
|
||||
|
||||
// Get the number of elements of a repeated field.
|
||||
virtual int FieldSize(const Message& message,
|
||||
const FieldDescriptor* field) const = 0;
|
||||
|
||||
// Clear the value of a field, so that HasField() returns false or
|
||||
// FieldSize() returns zero.
|
||||
virtual void ClearField(Message* message,
|
||||
const FieldDescriptor* field) const = 0;
|
||||
|
||||
// Remove the last element of a repeated field.
|
||||
// We don't provide a way to remove any element other than the last
|
||||
// because it invites inefficient use, such as O(n^2) filtering loops
|
||||
// that should have been O(n). If you want to remove an element other
|
||||
// than the last, the best way to do it is to re-arrange the elements
|
||||
// (using Swap()) so that the one you want removed is at the end, then
|
||||
// call RemoveLast().
|
||||
virtual void RemoveLast(Message* message,
|
||||
const FieldDescriptor* field) const = 0;
|
||||
|
||||
// Swap the complete contents of two messages.
|
||||
virtual void Swap(Message* message1, Message* message2) const = 0;
|
||||
|
||||
// Swap two elements of a repeated field.
|
||||
virtual void SwapElements(Message* message,
|
||||
const FieldDescriptor* field,
|
||||
int index1,
|
||||
int index2) const = 0;
|
||||
|
||||
// List all fields of the message which are currently set. This includes
|
||||
// extensions. Singular fields will only be listed if HasField(field) would
|
||||
// return true and repeated fields will only be listed if FieldSize(field)
|
||||
// would return non-zero. Fields (both normal fields and extension fields)
|
||||
// will be listed ordered by field number.
|
||||
virtual void ListFields(const Message& message,
|
||||
vector<const FieldDescriptor*>* output) const = 0;
|
||||
|
||||
// Singular field getters ------------------------------------------
|
||||
// These get the value of a non-repeated field. They return the default
|
||||
// value for fields that aren't set.
|
||||
|
||||
virtual int32 GetInt32 (const Message& message,
|
||||
const FieldDescriptor* field) const = 0;
|
||||
virtual int64 GetInt64 (const Message& message,
|
||||
const FieldDescriptor* field) const = 0;
|
||||
virtual uint32 GetUInt32(const Message& message,
|
||||
const FieldDescriptor* field) const = 0;
|
||||
virtual uint64 GetUInt64(const Message& message,
|
||||
const FieldDescriptor* field) const = 0;
|
||||
virtual float GetFloat (const Message& message,
|
||||
const FieldDescriptor* field) const = 0;
|
||||
virtual double GetDouble(const Message& message,
|
||||
const FieldDescriptor* field) const = 0;
|
||||
virtual bool GetBool (const Message& message,
|
||||
const FieldDescriptor* field) const = 0;
|
||||
virtual string GetString(const Message& message,
|
||||
const FieldDescriptor* field) const = 0;
|
||||
virtual const EnumValueDescriptor* GetEnum(
|
||||
const Message& message, const FieldDescriptor* field) const = 0;
|
||||
// See MutableMessage() for the meaning of the "factory" parameter.
|
||||
virtual const Message& GetMessage(const Message& message,
|
||||
const FieldDescriptor* field,
|
||||
MessageFactory* factory = NULL) const = 0;
|
||||
|
||||
// Get a string value without copying, if possible.
|
||||
//
|
||||
// GetString() necessarily returns a copy of the string. This can be
|
||||
// inefficient when the string is already stored in a string object in the
|
||||
// underlying message. GetStringReference() will return a reference to the
|
||||
// underlying string in this case. Otherwise, it will copy the string into
|
||||
// *scratch and return that.
|
||||
//
|
||||
// Note: It is perfectly reasonable and useful to write code like:
|
||||
// str = reflection->GetStringReference(field, &str);
|
||||
// This line would ensure that only one copy of the string is made
|
||||
// regardless of the field's underlying representation. When initializing
|
||||
// a newly-constructed string, though, it's just as fast and more readable
|
||||
// to use code like:
|
||||
// string str = reflection->GetString(field);
|
||||
virtual const string& GetStringReference(const Message& message,
|
||||
const FieldDescriptor* field,
|
||||
string* scratch) const = 0;
|
||||
|
||||
|
||||
// Singular field mutators -----------------------------------------
|
||||
// These mutate the value of a non-repeated field.
|
||||
|
||||
virtual void SetInt32 (Message* message,
|
||||
const FieldDescriptor* field, int32 value) const = 0;
|
||||
virtual void SetInt64 (Message* message,
|
||||
const FieldDescriptor* field, int64 value) const = 0;
|
||||
virtual void SetUInt32(Message* message,
|
||||
const FieldDescriptor* field, uint32 value) const = 0;
|
||||
virtual void SetUInt64(Message* message,
|
||||
const FieldDescriptor* field, uint64 value) const = 0;
|
||||
virtual void SetFloat (Message* message,
|
||||
const FieldDescriptor* field, float value) const = 0;
|
||||
virtual void SetDouble(Message* message,
|
||||
const FieldDescriptor* field, double value) const = 0;
|
||||
virtual void SetBool (Message* message,
|
||||
const FieldDescriptor* field, bool value) const = 0;
|
||||
virtual void SetString(Message* message,
|
||||
const FieldDescriptor* field,
|
||||
const string& value) const = 0;
|
||||
virtual void SetEnum (Message* message,
|
||||
const FieldDescriptor* field,
|
||||
const EnumValueDescriptor* value) const = 0;
|
||||
// Get a mutable pointer to a field with a message type. If a MessageFactory
|
||||
// is provided, it will be used to construct instances of the sub-message;
|
||||
// otherwise, the default factory is used. If the field is an extension that
|
||||
// does not live in the same pool as the containing message's descriptor (e.g.
|
||||
// it lives in an overlay pool), then a MessageFactory must be provided.
|
||||
// If you have no idea what that meant, then you probably don't need to worry
|
||||
// about it (don't provide a MessageFactory). WARNING: If the
|
||||
// FieldDescriptor is for a compiled-in extension, then
|
||||
// factory->GetPrototype(field->message_type() MUST return an instance of the
|
||||
// compiled-in class for this type, NOT DynamicMessage.
|
||||
virtual Message* MutableMessage(Message* message,
|
||||
const FieldDescriptor* field,
|
||||
MessageFactory* factory = NULL) const = 0;
|
||||
|
||||
|
||||
// Repeated field getters ------------------------------------------
|
||||
// These get the value of one element of a repeated field.
|
||||
|
||||
virtual int32 GetRepeatedInt32 (const Message& message,
|
||||
const FieldDescriptor* field,
|
||||
int index) const = 0;
|
||||
virtual int64 GetRepeatedInt64 (const Message& message,
|
||||
const FieldDescriptor* field,
|
||||
int index) const = 0;
|
||||
virtual uint32 GetRepeatedUInt32(const Message& message,
|
||||
const FieldDescriptor* field,
|
||||
int index) const = 0;
|
||||
virtual uint64 GetRepeatedUInt64(const Message& message,
|
||||
const FieldDescriptor* field,
|
||||
int index) const = 0;
|
||||
virtual float GetRepeatedFloat (const Message& message,
|
||||
const FieldDescriptor* field,
|
||||
int index) const = 0;
|
||||
virtual double GetRepeatedDouble(const Message& message,
|
||||
const FieldDescriptor* field,
|
||||
int index) const = 0;
|
||||
virtual bool GetRepeatedBool (const Message& message,
|
||||
const FieldDescriptor* field,
|
||||
int index) const = 0;
|
||||
virtual string GetRepeatedString(const Message& message,
|
||||
const FieldDescriptor* field,
|
||||
int index) const = 0;
|
||||
virtual const EnumValueDescriptor* GetRepeatedEnum(
|
||||
const Message& message,
|
||||
const FieldDescriptor* field, int index) const = 0;
|
||||
virtual const Message& GetRepeatedMessage(
|
||||
const Message& message,
|
||||
const FieldDescriptor* field, int index) const = 0;
|
||||
|
||||
// See GetStringReference(), above.
|
||||
virtual const string& GetRepeatedStringReference(
|
||||
const Message& message, const FieldDescriptor* field,
|
||||
int index, string* scratch) const = 0;
|
||||
|
||||
|
||||
// Repeated field mutators -----------------------------------------
|
||||
// These mutate the value of one element of a repeated field.
|
||||
|
||||
virtual void SetRepeatedInt32 (Message* message,
|
||||
const FieldDescriptor* field,
|
||||
int index, int32 value) const = 0;
|
||||
virtual void SetRepeatedInt64 (Message* message,
|
||||
const FieldDescriptor* field,
|
||||
int index, int64 value) const = 0;
|
||||
virtual void SetRepeatedUInt32(Message* message,
|
||||
const FieldDescriptor* field,
|
||||
int index, uint32 value) const = 0;
|
||||
virtual void SetRepeatedUInt64(Message* message,
|
||||
const FieldDescriptor* field,
|
||||
int index, uint64 value) const = 0;
|
||||
virtual void SetRepeatedFloat (Message* message,
|
||||
const FieldDescriptor* field,
|
||||
int index, float value) const = 0;
|
||||
virtual void SetRepeatedDouble(Message* message,
|
||||
const FieldDescriptor* field,
|
||||
int index, double value) const = 0;
|
||||
virtual void SetRepeatedBool (Message* message,
|
||||
const FieldDescriptor* field,
|
||||
int index, bool value) const = 0;
|
||||
virtual void SetRepeatedString(Message* message,
|
||||
const FieldDescriptor* field,
|
||||
int index, const string& value) const = 0;
|
||||
virtual void SetRepeatedEnum(Message* message,
|
||||
const FieldDescriptor* field, int index,
|
||||
const EnumValueDescriptor* value) const = 0;
|
||||
// Get a mutable pointer to an element of a repeated field with a message
|
||||
// type.
|
||||
virtual Message* MutableRepeatedMessage(
|
||||
Message* message, const FieldDescriptor* field, int index) const = 0;
|
||||
|
||||
|
||||
// Repeated field adders -------------------------------------------
|
||||
// These add an element to a repeated field.
|
||||
|
||||
virtual void AddInt32 (Message* message,
|
||||
const FieldDescriptor* field, int32 value) const = 0;
|
||||
virtual void AddInt64 (Message* message,
|
||||
const FieldDescriptor* field, int64 value) const = 0;
|
||||
virtual void AddUInt32(Message* message,
|
||||
const FieldDescriptor* field, uint32 value) const = 0;
|
||||
virtual void AddUInt64(Message* message,
|
||||
const FieldDescriptor* field, uint64 value) const = 0;
|
||||
virtual void AddFloat (Message* message,
|
||||
const FieldDescriptor* field, float value) const = 0;
|
||||
virtual void AddDouble(Message* message,
|
||||
const FieldDescriptor* field, double value) const = 0;
|
||||
virtual void AddBool (Message* message,
|
||||
const FieldDescriptor* field, bool value) const = 0;
|
||||
virtual void AddString(Message* message,
|
||||
const FieldDescriptor* field,
|
||||
const string& value) const = 0;
|
||||
virtual void AddEnum (Message* message,
|
||||
const FieldDescriptor* field,
|
||||
const EnumValueDescriptor* value) const = 0;
|
||||
// See MutableMessage() for comments on the "factory" parameter.
|
||||
virtual Message* AddMessage(Message* message,
|
||||
const FieldDescriptor* field,
|
||||
MessageFactory* factory = NULL) const = 0;
|
||||
|
||||
|
||||
// Extensions ------------------------------------------------------
|
||||
|
||||
// Try to find an extension of this message type by fully-qualified field
|
||||
// name. Returns NULL if no extension is known for this name or number.
|
||||
virtual const FieldDescriptor* FindKnownExtensionByName(
|
||||
const string& name) const = 0;
|
||||
|
||||
// Try to find an extension of this message type by field number.
|
||||
// Returns NULL if no extension is known for this name or number.
|
||||
virtual const FieldDescriptor* FindKnownExtensionByNumber(
|
||||
int number) const = 0;
|
||||
|
||||
private:
|
||||
GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(Reflection);
|
||||
};
|
||||
|
||||
// Abstract interface for a factory for message objects.
|
||||
class LIBPROTOBUF_EXPORT MessageFactory {
|
||||
public:
|
||||
inline MessageFactory() {}
|
||||
virtual ~MessageFactory();
|
||||
|
||||
// Given a Descriptor, gets or constructs the default (prototype) Message
|
||||
// of that type. You can then call that message's New() method to construct
|
||||
// a mutable message of that type.
|
||||
//
|
||||
// Calling this method twice with the same Descriptor returns the same
|
||||
// object. The returned object remains property of the factory. Also, any
|
||||
// objects created by calling the prototype's New() method share some data
|
||||
// with the prototype, so these must be destoyed before the MessageFactory
|
||||
// is destroyed.
|
||||
//
|
||||
// The given descriptor must outlive the returned message, and hence must
|
||||
// outlive the MessageFactory.
|
||||
//
|
||||
// Some implementations do not support all types. GetPrototype() will
|
||||
// return NULL if the descriptor passed in is not supported.
|
||||
//
|
||||
// This method may or may not be thread-safe depending on the implementation.
|
||||
// Each implementation should document its own degree thread-safety.
|
||||
virtual const Message* GetPrototype(const Descriptor* type) = 0;
|
||||
|
||||
// Gets a MessageFactory which supports all generated, compiled-in messages.
|
||||
// In other words, for any compiled-in type FooMessage, the following is true:
|
||||
// MessageFactory::generated_factory()->GetPrototype(
|
||||
// FooMessage::descriptor()) == FooMessage::default_instance()
|
||||
// This factory supports all types which are found in
|
||||
// DescriptorPool::generated_pool(). If given a descriptor from any other
|
||||
// pool, GetPrototype() will return NULL. (You can also check if a
|
||||
// descriptor is for a generated message by checking if
|
||||
// descriptor->file()->pool() == DescriptorPool::generated_pool().)
|
||||
//
|
||||
// This factory is 100% thread-safe; calling GetPrototype() does not modify
|
||||
// any shared data.
|
||||
//
|
||||
// This factory is a singleton. The caller must not delete the object.
|
||||
static MessageFactory* generated_factory();
|
||||
|
||||
// For internal use only: Registers a .proto file at static initialization
|
||||
// time, to be placed in generated_factory. The first time GetPrototype()
|
||||
// is called with a descriptor from this file, |register_messages| will be
|
||||
// called, with the file name as the parameter. It must call
|
||||
// InternalRegisterGeneratedMessage() (below) to register each message type
|
||||
// in the file. This strange mechanism is necessary because descriptors are
|
||||
// built lazily, so we can't register types by their descriptor until we
|
||||
// know that the descriptor exists. |filename| must be a permanent string.
|
||||
static void InternalRegisterGeneratedFile(
|
||||
const char* filename, void (*register_messages)(const string&));
|
||||
|
||||
// For internal use only: Registers a message type. Called only by the
|
||||
// functions which are registered with InternalRegisterGeneratedFile(),
|
||||
// above.
|
||||
static void InternalRegisterGeneratedMessage(const Descriptor* descriptor,
|
||||
const Message* prototype);
|
||||
|
||||
private:
|
||||
GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(MessageFactory);
|
||||
};
|
||||
|
||||
} // namespace protobuf
|
||||
|
||||
} // namespace google
|
||||
#endif // GOOGLE_PROTOBUF_MESSAGE_H__
|
||||
@ -1,334 +0,0 @@
|
||||
// Protocol Buffers - Google's data interchange format
|
||||
// Copyright 2008 Google Inc. All rights reserved.
|
||||
// http://code.google.com/p/protobuf/
|
||||
//
|
||||
// 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.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// 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.
|
||||
|
||||
// Authors: wink@google.com (Wink Saville),
|
||||
// kenton@google.com (Kenton Varda)
|
||||
// Based on original Protocol Buffers design by
|
||||
// Sanjay Ghemawat, Jeff Dean, and others.
|
||||
|
||||
#include <google/protobuf/message_lite.h>
|
||||
#include <string>
|
||||
#include <google/protobuf/stubs/common.h>
|
||||
#include <google/protobuf/io/coded_stream.h>
|
||||
#include <google/protobuf/io/zero_copy_stream_impl.h>
|
||||
#include <google/protobuf/stubs/stl_util-inl.h>
|
||||
|
||||
namespace google {
|
||||
namespace protobuf {
|
||||
|
||||
MessageLite::~MessageLite() {}
|
||||
|
||||
string MessageLite::InitializationErrorString() const {
|
||||
return "(cannot determine missing fields for lite message)";
|
||||
}
|
||||
|
||||
namespace {
|
||||
|
||||
// When serializing, we first compute the byte size, then serialize the message.
|
||||
// If serialization produces a different number of bytes than expected, we
|
||||
// call this function, which crashes. The problem could be due to a bug in the
|
||||
// protobuf implementation but is more likely caused by concurrent modification
|
||||
// of the message. This function attempts to distinguish between the two and
|
||||
// provide a useful error message.
|
||||
void ByteSizeConsistencyError(int byte_size_before_serialization,
|
||||
int byte_size_after_serialization,
|
||||
int bytes_produced_by_serialization) {
|
||||
GOOGLE_CHECK_EQ(byte_size_before_serialization, byte_size_after_serialization)
|
||||
<< "Protocol message was modified concurrently during serialization.";
|
||||
GOOGLE_CHECK_EQ(bytes_produced_by_serialization, byte_size_before_serialization)
|
||||
<< "Byte size calculation and serialization were inconsistent. This "
|
||||
"may indicate a bug in protocol buffers or it may be caused by "
|
||||
"concurrent modification of the message.";
|
||||
GOOGLE_LOG(FATAL) << "This shouldn't be called if all the sizes are equal.";
|
||||
}
|
||||
|
||||
string InitializationErrorMessage(const char* action,
|
||||
const MessageLite& message) {
|
||||
// Note: We want to avoid depending on strutil in the lite library, otherwise
|
||||
// we'd use:
|
||||
//
|
||||
// return strings::Substitute(
|
||||
// "Can't $0 message of type \"$1\" because it is missing required "
|
||||
// "fields: $2",
|
||||
// action, message.GetTypeName(),
|
||||
// message.InitializationErrorString());
|
||||
|
||||
string result;
|
||||
result += "Can't ";
|
||||
result += action;
|
||||
result += " message of type \"";
|
||||
result += message.GetTypeName();
|
||||
result += "\" because it is missing required fields: ";
|
||||
result += message.InitializationErrorString();
|
||||
return result;
|
||||
}
|
||||
|
||||
// Several of the Parse methods below just do one thing and then call another
|
||||
// method. In a naive implementation, we might have ParseFromString() call
|
||||
// ParseFromArray() which would call ParseFromZeroCopyStream() which would call
|
||||
// ParseFromCodedStream() which would call MergeFromCodedStream() which would
|
||||
// call MergePartialFromCodedStream(). However, when parsing very small
|
||||
// messages, every function call introduces significant overhead. To avoid
|
||||
// this without reproducing code, we use these forced-inline helpers.
|
||||
//
|
||||
// Note: GCC only allows GOOGLE_ATTRIBUTE_ALWAYS_INLINE on declarations, not
|
||||
// definitions.
|
||||
inline bool InlineMergeFromCodedStream(io::CodedInputStream* input,
|
||||
MessageLite* message)
|
||||
GOOGLE_ATTRIBUTE_ALWAYS_INLINE;
|
||||
inline bool InlineParseFromCodedStream(io::CodedInputStream* input,
|
||||
MessageLite* message)
|
||||
GOOGLE_ATTRIBUTE_ALWAYS_INLINE;
|
||||
inline bool InlineParsePartialFromCodedStream(io::CodedInputStream* input,
|
||||
MessageLite* message)
|
||||
GOOGLE_ATTRIBUTE_ALWAYS_INLINE;
|
||||
inline bool InlineParseFromArray(const void* data, int size,
|
||||
MessageLite* message)
|
||||
GOOGLE_ATTRIBUTE_ALWAYS_INLINE;
|
||||
inline bool InlineParsePartialFromArray(const void* data, int size,
|
||||
MessageLite* message)
|
||||
GOOGLE_ATTRIBUTE_ALWAYS_INLINE;
|
||||
|
||||
bool InlineMergeFromCodedStream(io::CodedInputStream* input,
|
||||
MessageLite* message) {
|
||||
if (!message->MergePartialFromCodedStream(input)) return false;
|
||||
if (!message->IsInitialized()) {
|
||||
GOOGLE_LOG(ERROR) << InitializationErrorMessage("parse", *message);
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
bool InlineParseFromCodedStream(io::CodedInputStream* input,
|
||||
MessageLite* message) {
|
||||
message->Clear();
|
||||
return InlineMergeFromCodedStream(input, message);
|
||||
}
|
||||
|
||||
bool InlineParsePartialFromCodedStream(io::CodedInputStream* input,
|
||||
MessageLite* message) {
|
||||
message->Clear();
|
||||
return message->MergePartialFromCodedStream(input);
|
||||
}
|
||||
|
||||
bool InlineParseFromArray(const void* data, int size, MessageLite* message) {
|
||||
io::CodedInputStream input(reinterpret_cast<const uint8*>(data), size);
|
||||
return InlineParseFromCodedStream(&input, message) &&
|
||||
input.ConsumedEntireMessage();
|
||||
}
|
||||
|
||||
bool InlineParsePartialFromArray(const void* data, int size,
|
||||
MessageLite* message) {
|
||||
io::CodedInputStream input(reinterpret_cast<const uint8*>(data), size);
|
||||
return InlineParsePartialFromCodedStream(&input, message) &&
|
||||
input.ConsumedEntireMessage();
|
||||
}
|
||||
|
||||
} // namespace
|
||||
|
||||
bool MessageLite::MergeFromCodedStream(io::CodedInputStream* input) {
|
||||
return InlineMergeFromCodedStream(input, this);
|
||||
}
|
||||
|
||||
bool MessageLite::ParseFromCodedStream(io::CodedInputStream* input) {
|
||||
return InlineParseFromCodedStream(input, this);
|
||||
}
|
||||
|
||||
bool MessageLite::ParsePartialFromCodedStream(io::CodedInputStream* input) {
|
||||
return InlineParsePartialFromCodedStream(input, this);
|
||||
}
|
||||
|
||||
bool MessageLite::ParseFromZeroCopyStream(io::ZeroCopyInputStream* input) {
|
||||
io::CodedInputStream decoder(input);
|
||||
return ParseFromCodedStream(&decoder) && decoder.ConsumedEntireMessage();
|
||||
}
|
||||
|
||||
bool MessageLite::ParsePartialFromZeroCopyStream(
|
||||
io::ZeroCopyInputStream* input) {
|
||||
io::CodedInputStream decoder(input);
|
||||
return ParsePartialFromCodedStream(&decoder) &&
|
||||
decoder.ConsumedEntireMessage();
|
||||
}
|
||||
|
||||
bool MessageLite::ParseFromBoundedZeroCopyStream(
|
||||
io::ZeroCopyInputStream* input, int size) {
|
||||
io::CodedInputStream decoder(input);
|
||||
decoder.PushLimit(size);
|
||||
return ParseFromCodedStream(&decoder) &&
|
||||
decoder.ConsumedEntireMessage() &&
|
||||
decoder.BytesUntilLimit() == 0;
|
||||
}
|
||||
|
||||
bool MessageLite::ParsePartialFromBoundedZeroCopyStream(
|
||||
io::ZeroCopyInputStream* input, int size) {
|
||||
io::CodedInputStream decoder(input);
|
||||
decoder.PushLimit(size);
|
||||
return ParsePartialFromCodedStream(&decoder) &&
|
||||
decoder.ConsumedEntireMessage() &&
|
||||
decoder.BytesUntilLimit() == 0;
|
||||
}
|
||||
|
||||
bool MessageLite::ParseFromString(const string& data) {
|
||||
return InlineParseFromArray(data.data(), data.size(), this);
|
||||
}
|
||||
|
||||
bool MessageLite::ParsePartialFromString(const string& data) {
|
||||
return InlineParsePartialFromArray(data.data(), data.size(), this);
|
||||
}
|
||||
|
||||
bool MessageLite::ParseFromArray(const void* data, int size) {
|
||||
return InlineParseFromArray(data, size, this);
|
||||
}
|
||||
|
||||
bool MessageLite::ParsePartialFromArray(const void* data, int size) {
|
||||
return InlineParsePartialFromArray(data, size, this);
|
||||
}
|
||||
|
||||
|
||||
// ===================================================================
|
||||
|
||||
uint8* MessageLite::SerializeWithCachedSizesToArray(uint8* target) const {
|
||||
// We only optimize this when using optimize_for = SPEED. In other cases
|
||||
// we just use the CodedOutputStream path.
|
||||
int size = GetCachedSize();
|
||||
io::ArrayOutputStream out(target, size);
|
||||
io::CodedOutputStream coded_out(&out);
|
||||
SerializeWithCachedSizes(&coded_out);
|
||||
GOOGLE_CHECK(!coded_out.HadError());
|
||||
return target + size;
|
||||
}
|
||||
|
||||
bool MessageLite::SerializeToCodedStream(io::CodedOutputStream* output) const {
|
||||
GOOGLE_DCHECK(IsInitialized()) << InitializationErrorMessage("serialize", *this);
|
||||
return SerializePartialToCodedStream(output);
|
||||
}
|
||||
|
||||
bool MessageLite::SerializePartialToCodedStream(
|
||||
io::CodedOutputStream* output) const {
|
||||
const int size = ByteSize(); // Force size to be cached.
|
||||
uint8* buffer = output->GetDirectBufferForNBytesAndAdvance(size);
|
||||
if (buffer != NULL) {
|
||||
uint8* end = SerializeWithCachedSizesToArray(buffer);
|
||||
if (end - buffer != size) {
|
||||
ByteSizeConsistencyError(size, ByteSize(), end - buffer);
|
||||
}
|
||||
return true;
|
||||
} else {
|
||||
int original_byte_count = output->ByteCount();
|
||||
SerializeWithCachedSizes(output);
|
||||
if (output->HadError()) {
|
||||
return false;
|
||||
}
|
||||
int final_byte_count = output->ByteCount();
|
||||
|
||||
if (final_byte_count - original_byte_count != size) {
|
||||
ByteSizeConsistencyError(size, ByteSize(),
|
||||
final_byte_count - original_byte_count);
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
bool MessageLite::SerializeToZeroCopyStream(
|
||||
io::ZeroCopyOutputStream* output) const {
|
||||
io::CodedOutputStream encoder(output);
|
||||
return SerializeToCodedStream(&encoder);
|
||||
}
|
||||
|
||||
bool MessageLite::SerializePartialToZeroCopyStream(
|
||||
io::ZeroCopyOutputStream* output) const {
|
||||
io::CodedOutputStream encoder(output);
|
||||
return SerializePartialToCodedStream(&encoder);
|
||||
}
|
||||
|
||||
bool MessageLite::AppendToString(string* output) const {
|
||||
GOOGLE_DCHECK(IsInitialized()) << InitializationErrorMessage("serialize", *this);
|
||||
return AppendPartialToString(output);
|
||||
}
|
||||
|
||||
bool MessageLite::AppendPartialToString(string* output) const {
|
||||
int old_size = output->size();
|
||||
int byte_size = ByteSize();
|
||||
STLStringResizeUninitialized(output, old_size + byte_size);
|
||||
uint8* start = reinterpret_cast<uint8*>(string_as_array(output) + old_size);
|
||||
uint8* end = SerializeWithCachedSizesToArray(start);
|
||||
if (end - start != byte_size) {
|
||||
ByteSizeConsistencyError(byte_size, ByteSize(), end - start);
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
bool MessageLite::SerializeToString(string* output) const {
|
||||
output->clear();
|
||||
return AppendToString(output);
|
||||
}
|
||||
|
||||
bool MessageLite::SerializePartialToString(string* output) const {
|
||||
output->clear();
|
||||
return AppendPartialToString(output);
|
||||
}
|
||||
|
||||
bool MessageLite::SerializeToArray(void* data, int size) const {
|
||||
GOOGLE_DCHECK(IsInitialized()) << InitializationErrorMessage("serialize", *this);
|
||||
return SerializePartialToArray(data, size);
|
||||
}
|
||||
|
||||
bool MessageLite::SerializePartialToArray(void* data, int size) const {
|
||||
int byte_size = ByteSize();
|
||||
if (size < byte_size) return false;
|
||||
uint8* start = reinterpret_cast<uint8*>(data);
|
||||
uint8* end = SerializeWithCachedSizesToArray(start);
|
||||
if (end - start != byte_size) {
|
||||
ByteSizeConsistencyError(byte_size, ByteSize(), end - start);
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
string MessageLite::SerializeAsString() const {
|
||||
// If the compiler implements the (Named) Return Value Optimization,
|
||||
// the local variable 'result' will not actually reside on the stack
|
||||
// of this function, but will be overlaid with the object that the
|
||||
// caller supplied for the return value to be constructed in.
|
||||
string output;
|
||||
if (!AppendToString(&output))
|
||||
output.clear();
|
||||
return output;
|
||||
}
|
||||
|
||||
string MessageLite::SerializePartialAsString() const {
|
||||
string output;
|
||||
if (!AppendPartialToString(&output))
|
||||
output.clear();
|
||||
return output;
|
||||
}
|
||||
|
||||
} // namespace protobuf
|
||||
} // namespace google
|
||||
@ -1,239 +0,0 @@
|
||||
// Protocol Buffers - Google's data interchange format
|
||||
// Copyright 2008 Google Inc. All rights reserved.
|
||||
// http://code.google.com/p/protobuf/
|
||||
//
|
||||
// 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.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// 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.
|
||||
|
||||
// Authors: wink@google.com (Wink Saville),
|
||||
// kenton@google.com (Kenton Varda)
|
||||
// Based on original Protocol Buffers design by
|
||||
// Sanjay Ghemawat, Jeff Dean, and others.
|
||||
//
|
||||
// Defines MessageLite, the abstract interface implemented by all (lite
|
||||
// and non-lite) protocol message objects.
|
||||
|
||||
#ifndef GOOGLE_PROTOBUF_MESSAGE_LITE_H__
|
||||
#define GOOGLE_PROTOBUF_MESSAGE_LITE_H__
|
||||
|
||||
#include <google/protobuf/stubs/common.h>
|
||||
#include <google/protobuf/io/coded_stream.h>
|
||||
|
||||
namespace google {
|
||||
namespace protobuf {
|
||||
|
||||
// Interface to light weight protocol messages.
|
||||
//
|
||||
// This interface is implemented by all protocol message objects. Non-lite
|
||||
// messages additionally implement the Message interface, which is a
|
||||
// subclass of MessageLite. Use MessageLite instead when you only need
|
||||
// the subset of features which it supports -- namely, nothing that uses
|
||||
// descriptors or reflection. You can instruct the protocol compiler
|
||||
// to generate classes which implement only MessageLite, not the full
|
||||
// Message interface, by adding the following line to the .proto file:
|
||||
//
|
||||
// option optimize_for = LITE_RUNTIME;
|
||||
//
|
||||
// This is particularly useful on resource-constrained systems where
|
||||
// the full protocol buffers runtime library is too big.
|
||||
//
|
||||
// Note that on non-constrained systems (e.g. servers) when you need
|
||||
// to link in lots of protocol definitions, a better way to reduce
|
||||
// total code footprint is to use optimize_for = CODE_SIZE. This
|
||||
// will make the generated code smaller while still supporting all the
|
||||
// same features (at the expense of speed). optimize_for = LITE_RUNTIME
|
||||
// is best when you only have a small number of message types linked
|
||||
// into your binary, in which case the size of the protocol buffers
|
||||
// runtime itself is the biggest problem.
|
||||
class LIBPROTOBUF_EXPORT MessageLite {
|
||||
public:
|
||||
inline MessageLite() {}
|
||||
virtual ~MessageLite();
|
||||
|
||||
// Basic Operations ------------------------------------------------
|
||||
|
||||
// Get the name of this message type, e.g. "foo.bar.BazProto".
|
||||
virtual string GetTypeName() const = 0;
|
||||
|
||||
// Construct a new instance of the same type. Ownership is passed to the
|
||||
// caller.
|
||||
virtual MessageLite* New() const = 0;
|
||||
|
||||
// Clear all fields of the message and set them to their default values.
|
||||
// Clear() avoids freeing memory, assuming that any memory allocated
|
||||
// to hold parts of the message will be needed again to hold the next
|
||||
// message. If you actually want to free the memory used by a Message,
|
||||
// you must delete it.
|
||||
virtual void Clear() = 0;
|
||||
|
||||
// Quickly check if all required fields have values set.
|
||||
virtual bool IsInitialized() const = 0;
|
||||
|
||||
// This is not implemented for Lite messages -- it just returns "(cannot
|
||||
// determine missing fields for lite message)". However, it is implemented
|
||||
// for full messages. See message.h.
|
||||
virtual string InitializationErrorString() const;
|
||||
|
||||
// If |other| is the exact same class as this, calls MergeFrom(). Otherwise,
|
||||
// results are undefined (probably crash).
|
||||
virtual void CheckTypeAndMergeFrom(const MessageLite& other) = 0;
|
||||
|
||||
// Parsing ---------------------------------------------------------
|
||||
// Methods for parsing in protocol buffer format. Most of these are
|
||||
// just simple wrappers around MergeFromCodedStream().
|
||||
|
||||
// Fill the message with a protocol buffer parsed from the given input
|
||||
// stream. Returns false on a read error or if the input is in the
|
||||
// wrong format.
|
||||
bool ParseFromCodedStream(io::CodedInputStream* input);
|
||||
// Like ParseFromCodedStream(), but accepts messages that are missing
|
||||
// required fields.
|
||||
bool ParsePartialFromCodedStream(io::CodedInputStream* input);
|
||||
// Read a protocol buffer from the given zero-copy input stream. If
|
||||
// successful, the entire input will be consumed.
|
||||
bool ParseFromZeroCopyStream(io::ZeroCopyInputStream* input);
|
||||
// Like ParseFromZeroCopyStream(), but accepts messages that are missing
|
||||
// required fields.
|
||||
bool ParsePartialFromZeroCopyStream(io::ZeroCopyInputStream* input);
|
||||
// Read a protocol buffer from the given zero-copy input stream, expecting
|
||||
// the message to be exactly "size" bytes long. If successful, exactly
|
||||
// this many bytes will have been consumed from the input.
|
||||
bool ParseFromBoundedZeroCopyStream(io::ZeroCopyInputStream* input, int size);
|
||||
// Like ParseFromBoundedZeroCopyStream(), but accepts messages that are
|
||||
// missing required fields.
|
||||
bool ParsePartialFromBoundedZeroCopyStream(io::ZeroCopyInputStream* input,
|
||||
int size);
|
||||
// Parse a protocol buffer contained in a string.
|
||||
bool ParseFromString(const string& data);
|
||||
// Like ParseFromString(), but accepts messages that are missing
|
||||
// required fields.
|
||||
bool ParsePartialFromString(const string& data);
|
||||
// Parse a protocol buffer contained in an array of bytes.
|
||||
bool ParseFromArray(const void* data, int size);
|
||||
// Like ParseFromArray(), but accepts messages that are missing
|
||||
// required fields.
|
||||
bool ParsePartialFromArray(const void* data, int size);
|
||||
|
||||
|
||||
// Reads a protocol buffer from the stream and merges it into this
|
||||
// Message. Singular fields read from the input overwrite what is
|
||||
// already in the Message and repeated fields are appended to those
|
||||
// already present.
|
||||
//
|
||||
// It is the responsibility of the caller to call input->LastTagWas()
|
||||
// (for groups) or input->ConsumedEntireMessage() (for non-groups) after
|
||||
// this returns to verify that the message's end was delimited correctly.
|
||||
//
|
||||
// ParsefromCodedStream() is implemented as Clear() followed by
|
||||
// MergeFromCodedStream().
|
||||
bool MergeFromCodedStream(io::CodedInputStream* input);
|
||||
|
||||
// Like MergeFromCodedStream(), but succeeds even if required fields are
|
||||
// missing in the input.
|
||||
//
|
||||
// MergeFromCodedStream() is just implemented as MergePartialFromCodedStream()
|
||||
// followed by IsInitialized().
|
||||
virtual bool MergePartialFromCodedStream(io::CodedInputStream* input) = 0;
|
||||
|
||||
// Serialization ---------------------------------------------------
|
||||
// Methods for serializing in protocol buffer format. Most of these
|
||||
// are just simple wrappers around ByteSize() and SerializeWithCachedSizes().
|
||||
|
||||
// Write a protocol buffer of this message to the given output. Returns
|
||||
// false on a write error. If the message is missing required fields,
|
||||
// this may GOOGLE_CHECK-fail.
|
||||
bool SerializeToCodedStream(io::CodedOutputStream* output) const;
|
||||
// Like SerializeToCodedStream(), but allows missing required fields.
|
||||
bool SerializePartialToCodedStream(io::CodedOutputStream* output) const;
|
||||
// Write the message to the given zero-copy output stream. All required
|
||||
// fields must be set.
|
||||
bool SerializeToZeroCopyStream(io::ZeroCopyOutputStream* output) const;
|
||||
// Like SerializeToZeroCopyStream(), but allows missing required fields.
|
||||
bool SerializePartialToZeroCopyStream(io::ZeroCopyOutputStream* output) const;
|
||||
// Serialize the message and store it in the given string. All required
|
||||
// fields must be set.
|
||||
bool SerializeToString(string* output) const;
|
||||
// Like SerializeToString(), but allows missing required fields.
|
||||
bool SerializePartialToString(string* output) const;
|
||||
// Serialize the message and store it in the given byte array. All required
|
||||
// fields must be set.
|
||||
bool SerializeToArray(void* data, int size) const;
|
||||
// Like SerializeToArray(), but allows missing required fields.
|
||||
bool SerializePartialToArray(void* data, int size) const;
|
||||
|
||||
// Make a string encoding the message. Is equivalent to calling
|
||||
// SerializeToString() on a string and using that. Returns the empty
|
||||
// string if SerializeToString() would have returned an error.
|
||||
// Note: If you intend to generate many such strings, you may
|
||||
// reduce heap fragmentation by instead re-using the same string
|
||||
// object with calls to SerializeToString().
|
||||
string SerializeAsString() const;
|
||||
// Like SerializeAsString(), but allows missing required fields.
|
||||
string SerializePartialAsString() const;
|
||||
|
||||
// Like SerializeToString(), but appends to the data to the string's existing
|
||||
// contents. All required fields must be set.
|
||||
bool AppendToString(string* output) const;
|
||||
// Like AppendToString(), but allows missing required fields.
|
||||
bool AppendPartialToString(string* output) const;
|
||||
|
||||
// Computes the serialized size of the message. This recursively calls
|
||||
// ByteSize() on all embedded messages. If a subclass does not override
|
||||
// this, it MUST override SetCachedSize().
|
||||
virtual int ByteSize() const = 0;
|
||||
|
||||
// Serializes the message without recomputing the size. The message must
|
||||
// not have changed since the last call to ByteSize(); if it has, the results
|
||||
// are undefined.
|
||||
virtual void SerializeWithCachedSizes(
|
||||
io::CodedOutputStream* output) const = 0;
|
||||
|
||||
// Like SerializeWithCachedSizes, but writes directly to *target, returning
|
||||
// a pointer to the byte immediately after the last byte written. "target"
|
||||
// must point at a byte array of at least ByteSize() bytes.
|
||||
virtual uint8* SerializeWithCachedSizesToArray(uint8* target) const;
|
||||
|
||||
// Returns the result of the last call to ByteSize(). An embedded message's
|
||||
// size is needed both to serialize it (because embedded messages are
|
||||
// length-delimited) and to compute the outer message's size. Caching
|
||||
// the size avoids computing it multiple times.
|
||||
//
|
||||
// ByteSize() does not automatically use the cached size when available
|
||||
// because this would require invalidating it every time the message was
|
||||
// modified, which would be too hard and expensive. (E.g. if a deeply-nested
|
||||
// sub-message is changed, all of its parents' cached sizes would need to be
|
||||
// invalidated, which is too much work for an otherwise inlined setter
|
||||
// method.)
|
||||
virtual int GetCachedSize() const = 0;
|
||||
|
||||
private:
|
||||
GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(MessageLite);
|
||||
};
|
||||
|
||||
} // namespace protobuf
|
||||
|
||||
} // namespace google
|
||||
#endif // GOOGLE_PROTOBUF_MESSAGE_LITE_H__
|
||||
@ -1,262 +0,0 @@
|
||||
// Protocol Buffers - Google's data interchange format
|
||||
// Copyright 2008 Google Inc. All rights reserved.
|
||||
// http://code.google.com/p/protobuf/
|
||||
//
|
||||
// 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.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// 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.
|
||||
|
||||
// Author: kenton@google.com (Kenton Varda)
|
||||
// Based on original Protocol Buffers design by
|
||||
// Sanjay Ghemawat, Jeff Dean, and others.
|
||||
|
||||
#include <google/protobuf/reflection_ops.h>
|
||||
#include <google/protobuf/descriptor.h>
|
||||
#include <google/protobuf/unknown_field_set.h>
|
||||
#include <google/protobuf/stubs/strutil.h>
|
||||
|
||||
namespace google {
|
||||
namespace protobuf {
|
||||
namespace internal {
|
||||
|
||||
void ReflectionOps::Copy(const Message& from, Message* to) {
|
||||
if (&from == to) return;
|
||||
Clear(to);
|
||||
Merge(from, to);
|
||||
}
|
||||
|
||||
void ReflectionOps::Merge(const Message& from, Message* to) {
|
||||
GOOGLE_CHECK_NE(&from, to);
|
||||
|
||||
const Descriptor* descriptor = from.GetDescriptor();
|
||||
GOOGLE_CHECK_EQ(to->GetDescriptor(), descriptor)
|
||||
<< "Tried to merge messages of different types.";
|
||||
|
||||
const Reflection* from_reflection = from.GetReflection();
|
||||
const Reflection* to_reflection = to->GetReflection();
|
||||
|
||||
vector<const FieldDescriptor*> fields;
|
||||
from_reflection->ListFields(from, &fields);
|
||||
for (int i = 0; i < fields.size(); i++) {
|
||||
const FieldDescriptor* field = fields[i];
|
||||
|
||||
if (field->is_repeated()) {
|
||||
int count = from_reflection->FieldSize(from, field);
|
||||
for (int j = 0; j < count; j++) {
|
||||
switch (field->cpp_type()) {
|
||||
#define HANDLE_TYPE(CPPTYPE, METHOD) \
|
||||
case FieldDescriptor::CPPTYPE_##CPPTYPE: \
|
||||
to_reflection->Add##METHOD(to, field, \
|
||||
from_reflection->GetRepeated##METHOD(from, field, j)); \
|
||||
break;
|
||||
|
||||
HANDLE_TYPE(INT32 , Int32 );
|
||||
HANDLE_TYPE(INT64 , Int64 );
|
||||
HANDLE_TYPE(UINT32, UInt32);
|
||||
HANDLE_TYPE(UINT64, UInt64);
|
||||
HANDLE_TYPE(FLOAT , Float );
|
||||
HANDLE_TYPE(DOUBLE, Double);
|
||||
HANDLE_TYPE(BOOL , Bool );
|
||||
HANDLE_TYPE(STRING, String);
|
||||
HANDLE_TYPE(ENUM , Enum );
|
||||
#undef HANDLE_TYPE
|
||||
|
||||
case FieldDescriptor::CPPTYPE_MESSAGE:
|
||||
to_reflection->AddMessage(to, field)->MergeFrom(
|
||||
from_reflection->GetRepeatedMessage(from, field, j));
|
||||
break;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
switch (field->cpp_type()) {
|
||||
#define HANDLE_TYPE(CPPTYPE, METHOD) \
|
||||
case FieldDescriptor::CPPTYPE_##CPPTYPE: \
|
||||
to_reflection->Set##METHOD(to, field, \
|
||||
from_reflection->Get##METHOD(from, field)); \
|
||||
break;
|
||||
|
||||
HANDLE_TYPE(INT32 , Int32 );
|
||||
HANDLE_TYPE(INT64 , Int64 );
|
||||
HANDLE_TYPE(UINT32, UInt32);
|
||||
HANDLE_TYPE(UINT64, UInt64);
|
||||
HANDLE_TYPE(FLOAT , Float );
|
||||
HANDLE_TYPE(DOUBLE, Double);
|
||||
HANDLE_TYPE(BOOL , Bool );
|
||||
HANDLE_TYPE(STRING, String);
|
||||
HANDLE_TYPE(ENUM , Enum );
|
||||
#undef HANDLE_TYPE
|
||||
|
||||
case FieldDescriptor::CPPTYPE_MESSAGE:
|
||||
to_reflection->MutableMessage(to, field)->MergeFrom(
|
||||
from_reflection->GetMessage(from, field));
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
to_reflection->MutableUnknownFields(to)->MergeFrom(
|
||||
from_reflection->GetUnknownFields(from));
|
||||
}
|
||||
|
||||
void ReflectionOps::Clear(Message* message) {
|
||||
const Reflection* reflection = message->GetReflection();
|
||||
|
||||
vector<const FieldDescriptor*> fields;
|
||||
reflection->ListFields(*message, &fields);
|
||||
for (int i = 0; i < fields.size(); i++) {
|
||||
reflection->ClearField(message, fields[i]);
|
||||
}
|
||||
|
||||
reflection->MutableUnknownFields(message)->Clear();
|
||||
}
|
||||
|
||||
bool ReflectionOps::IsInitialized(const Message& message) {
|
||||
const Descriptor* descriptor = message.GetDescriptor();
|
||||
const Reflection* reflection = message.GetReflection();
|
||||
|
||||
// Check required fields of this message.
|
||||
for (int i = 0; i < descriptor->field_count(); i++) {
|
||||
if (descriptor->field(i)->is_required()) {
|
||||
if (!reflection->HasField(message, descriptor->field(i))) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Check that sub-messages are initialized.
|
||||
vector<const FieldDescriptor*> fields;
|
||||
reflection->ListFields(message, &fields);
|
||||
for (int i = 0; i < fields.size(); i++) {
|
||||
const FieldDescriptor* field = fields[i];
|
||||
if (field->cpp_type() == FieldDescriptor::CPPTYPE_MESSAGE) {
|
||||
if (field->is_repeated()) {
|
||||
int size = reflection->FieldSize(message, field);
|
||||
|
||||
for (int i = 0; i < size; i++) {
|
||||
if (!reflection->GetRepeatedMessage(message, field, i)
|
||||
.IsInitialized()) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
if (!reflection->GetMessage(message, field).IsInitialized()) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
void ReflectionOps::DiscardUnknownFields(Message* message) {
|
||||
const Reflection* reflection = message->GetReflection();
|
||||
|
||||
reflection->MutableUnknownFields(message)->Clear();
|
||||
|
||||
vector<const FieldDescriptor*> fields;
|
||||
reflection->ListFields(*message, &fields);
|
||||
for (int i = 0; i < fields.size(); i++) {
|
||||
const FieldDescriptor* field = fields[i];
|
||||
if (field->cpp_type() == FieldDescriptor::CPPTYPE_MESSAGE) {
|
||||
if (field->is_repeated()) {
|
||||
int size = reflection->FieldSize(*message, field);
|
||||
for (int i = 0; i < size; i++) {
|
||||
reflection->MutableRepeatedMessage(message, field, i)
|
||||
->DiscardUnknownFields();
|
||||
}
|
||||
} else {
|
||||
reflection->MutableMessage(message, field)->DiscardUnknownFields();
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static string SubMessagePrefix(const string& prefix,
|
||||
const FieldDescriptor* field,
|
||||
int index) {
|
||||
string result(prefix);
|
||||
if (field->is_extension()) {
|
||||
result.append("(");
|
||||
result.append(field->full_name());
|
||||
result.append(")");
|
||||
} else {
|
||||
result.append(field->name());
|
||||
}
|
||||
if (index != -1) {
|
||||
result.append("[");
|
||||
result.append(SimpleItoa(index));
|
||||
result.append("]");
|
||||
}
|
||||
result.append(".");
|
||||
return result;
|
||||
}
|
||||
|
||||
void ReflectionOps::FindInitializationErrors(
|
||||
const Message& message,
|
||||
const string& prefix,
|
||||
vector<string>* errors) {
|
||||
const Descriptor* descriptor = message.GetDescriptor();
|
||||
const Reflection* reflection = message.GetReflection();
|
||||
|
||||
// Check required fields of this message.
|
||||
for (int i = 0; i < descriptor->field_count(); i++) {
|
||||
if (descriptor->field(i)->is_required()) {
|
||||
if (!reflection->HasField(message, descriptor->field(i))) {
|
||||
errors->push_back(prefix + descriptor->field(i)->name());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Check sub-messages.
|
||||
vector<const FieldDescriptor*> fields;
|
||||
reflection->ListFields(message, &fields);
|
||||
for (int i = 0; i < fields.size(); i++) {
|
||||
const FieldDescriptor* field = fields[i];
|
||||
if (field->cpp_type() == FieldDescriptor::CPPTYPE_MESSAGE) {
|
||||
|
||||
if (field->is_repeated()) {
|
||||
int size = reflection->FieldSize(message, field);
|
||||
|
||||
for (int i = 0; i < size; i++) {
|
||||
const Message& sub_message =
|
||||
reflection->GetRepeatedMessage(message, field, i);
|
||||
FindInitializationErrors(sub_message,
|
||||
SubMessagePrefix(prefix, field, i),
|
||||
errors);
|
||||
}
|
||||
} else {
|
||||
const Message& sub_message = reflection->GetMessage(message, field);
|
||||
FindInitializationErrors(sub_message,
|
||||
SubMessagePrefix(prefix, field, -1),
|
||||
errors);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
} // namespace internal
|
||||
} // namespace protobuf
|
||||
} // namespace google
|
||||
@ -1,98 +0,0 @@
|
||||
// Protocol Buffers - Google's data interchange format
|
||||
// Copyright 2008 Google Inc. All rights reserved.
|
||||
// http://code.google.com/p/protobuf/
|
||||
//
|
||||
// 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.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// 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.
|
||||
|
||||
// Author: kenton@google.com (Kenton Varda)
|
||||
// Based on original Protocol Buffers design by
|
||||
// Sanjay Ghemawat, Jeff Dean, and others.
|
||||
|
||||
#include <algorithm>
|
||||
|
||||
#include <google/protobuf/repeated_field.h>
|
||||
#include <google/protobuf/stubs/common.h>
|
||||
|
||||
namespace google {
|
||||
namespace protobuf {
|
||||
|
||||
namespace internal {
|
||||
|
||||
void RepeatedPtrFieldBase::Reserve(int new_size) {
|
||||
if (total_size_ >= new_size) return;
|
||||
|
||||
void** old_elements = elements_;
|
||||
total_size_ = max(total_size_ * 2, new_size);
|
||||
elements_ = new void*[total_size_];
|
||||
memcpy(elements_, old_elements, allocated_size_ * sizeof(elements_[0]));
|
||||
if (old_elements != initial_space_) {
|
||||
delete [] old_elements;
|
||||
}
|
||||
}
|
||||
|
||||
void RepeatedPtrFieldBase::Swap(RepeatedPtrFieldBase* other) {
|
||||
void** swap_elements = elements_;
|
||||
int swap_current_size = current_size_;
|
||||
int swap_allocated_size = allocated_size_;
|
||||
int swap_total_size = total_size_;
|
||||
// We may not be using initial_space_ but it's not worth checking. Just
|
||||
// copy it anyway.
|
||||
void* swap_initial_space[kInitialSize];
|
||||
memcpy(swap_initial_space, initial_space_, sizeof(initial_space_));
|
||||
|
||||
elements_ = other->elements_;
|
||||
current_size_ = other->current_size_;
|
||||
allocated_size_ = other->allocated_size_;
|
||||
total_size_ = other->total_size_;
|
||||
memcpy(initial_space_, other->initial_space_, sizeof(initial_space_));
|
||||
|
||||
other->elements_ = swap_elements;
|
||||
other->current_size_ = swap_current_size;
|
||||
other->allocated_size_ = swap_allocated_size;
|
||||
other->total_size_ = swap_total_size;
|
||||
memcpy(other->initial_space_, swap_initial_space, sizeof(swap_initial_space));
|
||||
|
||||
if (elements_ == other->initial_space_) {
|
||||
elements_ = initial_space_;
|
||||
}
|
||||
if (other->elements_ == initial_space_) {
|
||||
other->elements_ = other->initial_space_;
|
||||
}
|
||||
}
|
||||
|
||||
string* StringTypeHandlerBase::New() {
|
||||
return new string;
|
||||
}
|
||||
void StringTypeHandlerBase::Delete(string* value) {
|
||||
delete value;
|
||||
}
|
||||
|
||||
} // namespace internal
|
||||
|
||||
|
||||
} // namespace protobuf
|
||||
} // namespace google
|
||||
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
@ -1,438 +0,0 @@
|
||||
// Protocol Buffers - Google's data interchange format
|
||||
// Copyright 2008 Google Inc. All rights reserved.
|
||||
// https://developers.google.com/protocol-buffers/
|
||||
//
|
||||
// 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.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// 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.
|
||||
|
||||
// Author: kenton@google.com (Kenton Varda)
|
||||
//
|
||||
// Deals with the fact that hash_map is not defined everywhere.
|
||||
|
||||
#ifndef GOOGLE_PROTOBUF_STUBS_HASH_H__
|
||||
#define GOOGLE_PROTOBUF_STUBS_HASH_H__
|
||||
|
||||
#include <string.h>
|
||||
#include <google/protobuf/stubs/common.h>
|
||||
|
||||
#define GOOGLE_PROTOBUF_HAVE_HASH_MAP 1
|
||||
#define GOOGLE_PROTOBUF_HAVE_HASH_SET 1
|
||||
|
||||
// Android
|
||||
#if defined(__ANDROID__)
|
||||
# undef GOOGLE_PROTOBUF_HAVE_HASH_MAP
|
||||
# undef GOOGLE_PROTOBUF_HAVE_HASH_MAP
|
||||
|
||||
// Use C++11 unordered_{map|set} if available.
|
||||
#elif ((_LIBCPP_STD_VER >= 11) || \
|
||||
(((__cplusplus >= 201103L) || defined(__GXX_EXPERIMENTAL_CXX0X)) && \
|
||||
(__GLIBCXX__ > 20090421)))
|
||||
# define GOOGLE_PROTOBUF_HAS_CXX11_HASH
|
||||
|
||||
// For XCode >= 4.6: the compiler is clang with libc++.
|
||||
// For earlier XCode version: the compiler is gcc-4.2.1 with libstdc++.
|
||||
// libc++ provides <unordered_map> and friends even in non C++11 mode,
|
||||
// and it does not provide the tr1 library. Therefore the following macro
|
||||
// checks against this special case.
|
||||
// Note that we should not test the __APPLE_CC__ version number or the
|
||||
// __clang__ macro, since the new compiler can still use -stdlib=libstdc++, in
|
||||
// which case <unordered_map> is not compilable without -std=c++11
|
||||
#elif defined(__APPLE_CC__)
|
||||
# if __GNUC__ >= 4
|
||||
# define GOOGLE_PROTOBUF_HAS_TR1
|
||||
# else
|
||||
// Not tested for gcc < 4... These setting can compile under 4.2.1 though.
|
||||
# define GOOGLE_PROTOBUF_HASH_NAMESPACE __gnu_cxx
|
||||
# include <ext/hash_map>
|
||||
# define GOOGLE_PROTOBUF_HASH_MAP_CLASS hash_map
|
||||
# include <ext/hash_set>
|
||||
# define GOOGLE_PROTOBUF_HASH_SET_CLASS hash_set
|
||||
# endif
|
||||
|
||||
// Version checks for gcc.
|
||||
#elif defined(__GNUC__)
|
||||
// For GCC 4.x+, use tr1::unordered_map/set; otherwise, follow the
|
||||
// instructions from:
|
||||
// https://gcc.gnu.org/onlinedocs/libstdc++/manual/backwards.html
|
||||
# if __GNUC__ >= 4
|
||||
# define GOOGLE_PROTOBUF_HAS_TR1
|
||||
# elif __GNUC__ >= 3
|
||||
# include <backward/hash_map>
|
||||
# define GOOGLE_PROTOBUF_HASH_MAP_CLASS hash_map
|
||||
# include <backward/hash_set>
|
||||
# define GOOGLE_PROTOBUF_HASH_SET_CLASS hash_set
|
||||
# if __GNUC__ == 3 && __GNUC_MINOR__ == 0
|
||||
# define GOOGLE_PROTOBUF_HASH_NAMESPACE std // GCC 3.0
|
||||
# else
|
||||
# define GOOGLE_PROTOBUF_HASH_NAMESPACE __gnu_cxx // GCC 3.1 and later
|
||||
# endif
|
||||
# else
|
||||
# define GOOGLE_PROTOBUF_HASH_NAMESPACE
|
||||
# include <hash_map>
|
||||
# define GOOGLE_PROTOBUF_HASH_MAP_CLASS hash_map
|
||||
# include <hash_set>
|
||||
# define GOOGLE_PROTOBUF_HASH_SET_CLASS hash_set
|
||||
# endif
|
||||
|
||||
// Version checks for MSC.
|
||||
// Apparently Microsoft decided to move hash_map *back* to the std namespace in
|
||||
// MSVC 2010:
|
||||
// http://blogs.msdn.com/vcblog/archive/2009/05/25/stl-breaking-changes-in-visual-studio-2010-beta-1.aspx
|
||||
// And.. they are moved back to stdext in MSVC 2013 (haven't checked 2012). That
|
||||
// said, use unordered_map for MSVC 2010 and beyond is our safest bet.
|
||||
#elif defined(_MSC_VER)
|
||||
# if _MSC_VER >= 1600 // Since Visual Studio 2010
|
||||
# define GOOGLE_PROTOBUF_HAS_CXX11_HASH
|
||||
# define GOOGLE_PROTOBUF_HASH_COMPARE std::hash_compare
|
||||
# elif _MSC_VER >= 1500 // Since Visual Studio 2008
|
||||
# define GOOGLE_PROTOBUF_HASH_NAMESPACE stdext
|
||||
# include <hash_map>
|
||||
# define GOOGLE_PROTOBUF_HASH_MAP_CLASS hash_map
|
||||
# include <hash_set>
|
||||
# define GOOGLE_PROTOBUF_HASH_SET_CLASS hash_set
|
||||
# define GOOGLE_PROTOBUF_HASH_COMPARE stdext::hash_compare
|
||||
# define GOOGLE_PROTOBUF_CONTAINERS_NEED_HASH_COMPARE
|
||||
# elif _MSC_VER >= 1310
|
||||
# define GOOGLE_PROTOBUF_HASH_NAMESPACE stdext
|
||||
# include <hash_map>
|
||||
# define GOOGLE_PROTOBUF_HASH_MAP_CLASS hash_map
|
||||
# include <hash_set>
|
||||
# define GOOGLE_PROTOBUF_HASH_SET_CLASS hash_set
|
||||
# define GOOGLE_PROTOBUF_HASH_COMPARE stdext::hash_compare
|
||||
# else
|
||||
# define GOOGLE_PROTOBUF_HASH_NAMESPACE std
|
||||
# include <hash_map>
|
||||
# define GOOGLE_PROTOBUF_HASH_MAP_CLASS hash_map
|
||||
# include <hash_set>
|
||||
# define GOOGLE_PROTOBUF_HASH_SET_CLASS hash_set
|
||||
# define GOOGLE_PROTOBUF_HASH_COMPARE stdext::hash_compare
|
||||
# endif
|
||||
|
||||
// **ADD NEW COMPILERS SUPPORT HERE.**
|
||||
// For other compilers, undefine the macro and fallback to use std::map, in
|
||||
// google/protobuf/stubs/hash.h
|
||||
#else
|
||||
# undef GOOGLE_PROTOBUF_HAVE_HASH_MAP
|
||||
# undef GOOGLE_PROTOBUF_HAVE_HASH_SET
|
||||
#endif
|
||||
|
||||
#if defined(GOOGLE_PROTOBUF_HAS_CXX11_HASH)
|
||||
# define GOOGLE_PROTOBUF_HASH_NAMESPACE std
|
||||
# include <unordered_map>
|
||||
# define GOOGLE_PROTOBUF_HASH_MAP_CLASS unordered_map
|
||||
# include <unordered_set>
|
||||
# define GOOGLE_PROTOBUF_HASH_SET_CLASS unordered_set
|
||||
#elif defined(GOOGLE_PROTOBUF_HAS_TR1)
|
||||
# define GOOGLE_PROTOBUF_HASH_NAMESPACE std::tr1
|
||||
# include <tr1/unordered_map>
|
||||
# define GOOGLE_PROTOBUF_HASH_MAP_CLASS unordered_map
|
||||
# include <tr1/unordered_set>
|
||||
# define GOOGLE_PROTOBUF_HASH_SET_CLASS unordered_set
|
||||
#endif
|
||||
|
||||
# define GOOGLE_PROTOBUF_HASH_NAMESPACE_DECLARATION_START \
|
||||
namespace google { \
|
||||
namespace protobuf {
|
||||
# define GOOGLE_PROTOBUF_HASH_NAMESPACE_DECLARATION_END }}
|
||||
|
||||
#undef GOOGLE_PROTOBUF_HAS_CXX11_HASH
|
||||
#undef GOOGLE_PROTOBUF_HAS_TR1
|
||||
|
||||
#if defined(GOOGLE_PROTOBUF_HAVE_HASH_MAP) && \
|
||||
defined(GOOGLE_PROTOBUF_HAVE_HASH_SET)
|
||||
#else
|
||||
#define GOOGLE_PROTOBUF_MISSING_HASH
|
||||
#include <map>
|
||||
#include <set>
|
||||
#endif
|
||||
|
||||
namespace google {
|
||||
namespace protobuf {
|
||||
|
||||
#ifdef GOOGLE_PROTOBUF_MISSING_HASH
|
||||
#undef GOOGLE_PROTOBUF_MISSING_HASH
|
||||
|
||||
// This system doesn't have hash_map or hash_set. Emulate them using map and
|
||||
// set.
|
||||
|
||||
// Make hash<T> be the same as less<T>. Note that everywhere where custom
|
||||
// hash functions are defined in the protobuf code, they are also defined such
|
||||
// that they can be used as "less" functions, which is required by MSVC anyway.
|
||||
template <typename Key>
|
||||
struct hash {
|
||||
// Dummy, just to make derivative hash functions compile.
|
||||
int operator()(const Key& key) {
|
||||
GOOGLE_LOG(FATAL) << "Should never be called.";
|
||||
return 0;
|
||||
}
|
||||
|
||||
inline bool operator()(const Key& a, const Key& b) const {
|
||||
return a < b;
|
||||
}
|
||||
};
|
||||
|
||||
// Make sure char* is compared by value.
|
||||
template <>
|
||||
struct hash<const char*> {
|
||||
// Dummy, just to make derivative hash functions compile.
|
||||
int operator()(const char* key) {
|
||||
GOOGLE_LOG(FATAL) << "Should never be called.";
|
||||
return 0;
|
||||
}
|
||||
|
||||
inline bool operator()(const char* a, const char* b) const {
|
||||
return strcmp(a, b) < 0;
|
||||
}
|
||||
};
|
||||
|
||||
template <typename Key, typename Data,
|
||||
typename HashFcn = hash<Key>,
|
||||
typename EqualKey = std::equal_to<Key>,
|
||||
typename Alloc = std::allocator< std::pair<const Key, Data> > >
|
||||
class hash_map : public std::map<Key, Data, HashFcn, Alloc> {
|
||||
typedef std::map<Key, Data, HashFcn, Alloc> BaseClass;
|
||||
|
||||
public:
|
||||
hash_map(int a = 0, const HashFcn& b = HashFcn(),
|
||||
const EqualKey& c = EqualKey(),
|
||||
const Alloc& d = Alloc()) : BaseClass(b, d) {}
|
||||
|
||||
HashFcn hash_function() const { return HashFcn(); }
|
||||
};
|
||||
|
||||
template <typename Key,
|
||||
typename HashFcn = hash<Key>,
|
||||
typename EqualKey = std::equal_to<Key> >
|
||||
class hash_set : public std::set<Key, HashFcn> {
|
||||
public:
|
||||
hash_set(int = 0) {}
|
||||
|
||||
HashFcn hash_function() const { return HashFcn(); }
|
||||
};
|
||||
|
||||
#elif defined(_MSC_VER) && !defined(_STLPORT_VERSION)
|
||||
|
||||
template <typename Key>
|
||||
struct hash : public GOOGLE_PROTOBUF_HASH_COMPARE<Key> {
|
||||
};
|
||||
|
||||
// MSVC's hash_compare<const char*> hashes based on the string contents but
|
||||
// compares based on the string pointer. WTF?
|
||||
class CstringLess {
|
||||
public:
|
||||
inline bool operator()(const char* a, const char* b) const {
|
||||
return strcmp(a, b) < 0;
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct hash<const char*>
|
||||
: public GOOGLE_PROTOBUF_HASH_COMPARE<const char*, CstringLess> {};
|
||||
|
||||
#ifdef GOOGLE_PROTOBUF_CONTAINERS_NEED_HASH_COMPARE
|
||||
|
||||
template <typename Key, typename HashFcn, typename EqualKey>
|
||||
struct InternalHashCompare : public GOOGLE_PROTOBUF_HASH_COMPARE<Key> {
|
||||
InternalHashCompare() {}
|
||||
InternalHashCompare(HashFcn hashfcn, EqualKey equalkey)
|
||||
: hashfcn_(hashfcn), equalkey_(equalkey) {}
|
||||
size_t operator()(const Key& key) const { return hashfcn_(key); }
|
||||
bool operator()(const Key& key1, const Key& key2) const {
|
||||
return !equalkey_(key1, key2);
|
||||
}
|
||||
HashFcn hashfcn_;
|
||||
EqualKey equalkey_;
|
||||
};
|
||||
|
||||
template <typename Key, typename Data,
|
||||
typename HashFcn = hash<Key>,
|
||||
typename EqualKey = std::equal_to<Key>,
|
||||
typename Alloc = std::allocator< std::pair<const Key, Data> > >
|
||||
class hash_map
|
||||
: public GOOGLE_PROTOBUF_HASH_NAMESPACE::GOOGLE_PROTOBUF_HASH_MAP_CLASS<
|
||||
Key, Data, InternalHashCompare<Key, HashFcn, EqualKey>, Alloc> {
|
||||
typedef GOOGLE_PROTOBUF_HASH_NAMESPACE::GOOGLE_PROTOBUF_HASH_MAP_CLASS<
|
||||
Key, Data, InternalHashCompare<Key, HashFcn, EqualKey>, Alloc> BaseClass;
|
||||
|
||||
public:
|
||||
hash_map(int a = 0, const HashFcn& b = HashFcn(),
|
||||
const EqualKey& c = EqualKey(), const Alloc& d = Alloc())
|
||||
: BaseClass(InternalHashCompare<Key, HashFcn, EqualKey>(b, c), d) {}
|
||||
|
||||
HashFcn hash_function() const { return HashFcn(); }
|
||||
};
|
||||
|
||||
template <typename Key, typename HashFcn = hash<Key>,
|
||||
typename EqualKey = std::equal_to<Key> >
|
||||
class hash_set
|
||||
: public GOOGLE_PROTOBUF_HASH_NAMESPACE::GOOGLE_PROTOBUF_HASH_SET_CLASS<
|
||||
Key, InternalHashCompare<Key, HashFcn, EqualKey> > {
|
||||
public:
|
||||
hash_set(int = 0) {}
|
||||
|
||||
HashFcn hash_function() const { return HashFcn(); }
|
||||
};
|
||||
|
||||
#else // GOOGLE_PROTOBUF_CONTAINERS_NEED_HASH_COMPARE
|
||||
|
||||
template <typename Key, typename Data,
|
||||
typename HashFcn = hash<Key>,
|
||||
typename EqualKey = std::equal_to<Key>,
|
||||
typename Alloc = std::allocator< std::pair<const Key, Data> > >
|
||||
class hash_map
|
||||
: public GOOGLE_PROTOBUF_HASH_NAMESPACE::GOOGLE_PROTOBUF_HASH_MAP_CLASS<
|
||||
Key, Data, HashFcn, EqualKey, Alloc> {
|
||||
typedef GOOGLE_PROTOBUF_HASH_NAMESPACE::GOOGLE_PROTOBUF_HASH_MAP_CLASS<
|
||||
Key, Data, HashFcn, EqualKey, Alloc> BaseClass;
|
||||
|
||||
public:
|
||||
hash_map(int a = 0, const HashFcn& b = HashFcn(),
|
||||
const EqualKey& c = EqualKey(),
|
||||
const Alloc& d = Alloc()) : BaseClass(a, b, c, d) {}
|
||||
|
||||
HashFcn hash_function() const { return HashFcn(); }
|
||||
};
|
||||
|
||||
template <typename Key, typename HashFcn = hash<Key>,
|
||||
typename EqualKey = std::equal_to<Key> >
|
||||
class hash_set
|
||||
: public GOOGLE_PROTOBUF_HASH_NAMESPACE::GOOGLE_PROTOBUF_HASH_SET_CLASS<
|
||||
Key, HashFcn, EqualKey> {
|
||||
public:
|
||||
hash_set(int = 0) {}
|
||||
|
||||
HashFcn hash_function() const { return HashFcn(); }
|
||||
};
|
||||
#endif // GOOGLE_PROTOBUF_CONTAINERS_NEED_HASH_COMPARE
|
||||
|
||||
#else // defined(_MSC_VER) && !defined(_STLPORT_VERSION)
|
||||
|
||||
template <typename Key>
|
||||
struct hash : public GOOGLE_PROTOBUF_HASH_NAMESPACE::hash<Key> {
|
||||
};
|
||||
|
||||
template <typename Key>
|
||||
struct hash<const Key*> {
|
||||
inline size_t operator()(const Key* key) const {
|
||||
return reinterpret_cast<size_t>(key);
|
||||
}
|
||||
};
|
||||
|
||||
// Unlike the old SGI version, the TR1 "hash" does not special-case char*. So,
|
||||
// we go ahead and provide our own implementation.
|
||||
template <>
|
||||
struct hash<const char*> {
|
||||
inline size_t operator()(const char* str) const {
|
||||
size_t result = 0;
|
||||
for (; *str != '\0'; str++) {
|
||||
result = 5 * result + *str;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
};
|
||||
|
||||
template<>
|
||||
struct hash<bool> {
|
||||
size_t operator()(bool x) const {
|
||||
return static_cast<size_t>(x);
|
||||
}
|
||||
};
|
||||
|
||||
template <typename Key, typename Data,
|
||||
typename HashFcn = hash<Key>,
|
||||
typename EqualKey = std::equal_to<Key>,
|
||||
typename Alloc = std::allocator< std::pair<const Key, Data> > >
|
||||
class hash_map
|
||||
: public GOOGLE_PROTOBUF_HASH_NAMESPACE::GOOGLE_PROTOBUF_HASH_MAP_CLASS<
|
||||
Key, Data, HashFcn, EqualKey, Alloc> {
|
||||
typedef GOOGLE_PROTOBUF_HASH_NAMESPACE::GOOGLE_PROTOBUF_HASH_MAP_CLASS<
|
||||
Key, Data, HashFcn, EqualKey, Alloc> BaseClass;
|
||||
|
||||
public:
|
||||
hash_map(int a = 0, const HashFcn& b = HashFcn(),
|
||||
const EqualKey& c = EqualKey(),
|
||||
const Alloc& d = Alloc()) : BaseClass(a, b, c, d) {}
|
||||
|
||||
HashFcn hash_function() const { return HashFcn(); }
|
||||
};
|
||||
|
||||
template <typename Key, typename HashFcn = hash<Key>,
|
||||
typename EqualKey = std::equal_to<Key> >
|
||||
class hash_set
|
||||
: public GOOGLE_PROTOBUF_HASH_NAMESPACE::GOOGLE_PROTOBUF_HASH_SET_CLASS<
|
||||
Key, HashFcn, EqualKey> {
|
||||
public:
|
||||
hash_set(int = 0) {}
|
||||
|
||||
HashFcn hash_function() const { return HashFcn(); }
|
||||
};
|
||||
|
||||
#endif // !GOOGLE_PROTOBUF_MISSING_HASH
|
||||
|
||||
template <>
|
||||
struct hash<string> {
|
||||
inline size_t operator()(const string& key) const {
|
||||
return hash<const char*>()(key.c_str());
|
||||
}
|
||||
|
||||
static const size_t bucket_size = 4;
|
||||
static const size_t min_buckets = 8;
|
||||
inline bool operator()(const string& a, const string& b) const {
|
||||
return a < b;
|
||||
}
|
||||
};
|
||||
|
||||
template <typename First, typename Second>
|
||||
struct hash<pair<First, Second> > {
|
||||
inline size_t operator()(const pair<First, Second>& key) const {
|
||||
size_t first_hash = hash<First>()(key.first);
|
||||
size_t second_hash = hash<Second>()(key.second);
|
||||
|
||||
// FIXME(kenton): What is the best way to compute this hash? I have
|
||||
// no idea! This seems a bit better than an XOR.
|
||||
return first_hash * ((1 << 16) - 1) + second_hash;
|
||||
}
|
||||
|
||||
static const size_t bucket_size = 4;
|
||||
static const size_t min_buckets = 8;
|
||||
inline bool operator()(const pair<First, Second>& a,
|
||||
const pair<First, Second>& b) const {
|
||||
return a < b;
|
||||
}
|
||||
};
|
||||
|
||||
// Used by GCC/SGI STL only. (Why isn't this provided by the standard
|
||||
// library? :( )
|
||||
struct streq {
|
||||
inline bool operator()(const char* a, const char* b) const {
|
||||
return strcmp(a, b) == 0;
|
||||
}
|
||||
};
|
||||
|
||||
} // namespace protobuf
|
||||
} // namespace google
|
||||
|
||||
#endif // GOOGLE_PROTOBUF_STUBS_HASH_H__
|
||||
@ -1,119 +0,0 @@
|
||||
// Protocol Buffers - Google's data interchange format
|
||||
// Copyright 2008 Google Inc. All rights reserved.
|
||||
// http://code.google.com/p/protobuf/
|
||||
//
|
||||
// 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.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// 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.
|
||||
|
||||
// from google3/util/gtl/map-util.h
|
||||
// Author: Anton Carver
|
||||
|
||||
#ifndef GOOGLE_PROTOBUF_STUBS_MAP_UTIL_H__
|
||||
#define GOOGLE_PROTOBUF_STUBS_MAP_UTIL_H__
|
||||
|
||||
#include <google/protobuf/stubs/common.h>
|
||||
|
||||
namespace google {
|
||||
namespace protobuf {
|
||||
|
||||
// Perform a lookup in a map or hash_map.
|
||||
// If the key is present in the map then the value associated with that
|
||||
// key is returned, otherwise the value passed as a default is returned.
|
||||
template <class Collection>
|
||||
const typename Collection::value_type::second_type&
|
||||
FindWithDefault(const Collection& collection,
|
||||
const typename Collection::value_type::first_type& key,
|
||||
const typename Collection::value_type::second_type& value) {
|
||||
typename Collection::const_iterator it = collection.find(key);
|
||||
if (it == collection.end()) {
|
||||
return value;
|
||||
}
|
||||
return it->second;
|
||||
}
|
||||
|
||||
// Perform a lookup in a map or hash_map.
|
||||
// If the key is present a const pointer to the associated value is returned,
|
||||
// otherwise a NULL pointer is returned.
|
||||
template <class Collection>
|
||||
const typename Collection::value_type::second_type*
|
||||
FindOrNull(const Collection& collection,
|
||||
const typename Collection::value_type::first_type& key) {
|
||||
typename Collection::const_iterator it = collection.find(key);
|
||||
if (it == collection.end()) {
|
||||
return 0;
|
||||
}
|
||||
return &it->second;
|
||||
}
|
||||
|
||||
// Perform a lookup in a map or hash_map whose values are pointers.
|
||||
// If the key is present a const pointer to the associated value is returned,
|
||||
// otherwise a NULL pointer is returned.
|
||||
// This function does not distinguish between a missing key and a key mapped
|
||||
// to a NULL value.
|
||||
template <class Collection>
|
||||
const typename Collection::value_type::second_type
|
||||
FindPtrOrNull(const Collection& collection,
|
||||
const typename Collection::value_type::first_type& key) {
|
||||
typename Collection::const_iterator it = collection.find(key);
|
||||
if (it == collection.end()) {
|
||||
return 0;
|
||||
}
|
||||
return it->second;
|
||||
}
|
||||
|
||||
// Change the value associated with a particular key in a map or hash_map.
|
||||
// If the key is not present in the map the key and value are inserted,
|
||||
// otherwise the value is updated to be a copy of the value provided.
|
||||
// True indicates that an insert took place, false indicates an update.
|
||||
template <class Collection, class Key, class Value>
|
||||
bool InsertOrUpdate(Collection * const collection,
|
||||
const Key& key, const Value& value) {
|
||||
pair<typename Collection::iterator, bool> ret =
|
||||
collection->insert(typename Collection::value_type(key, value));
|
||||
if (!ret.second) {
|
||||
// update
|
||||
ret.first->second = value;
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
// Insert a new key and value into a map or hash_map.
|
||||
// If the key is not present in the map the key and value are
|
||||
// inserted, otherwise nothing happens. True indicates that an insert
|
||||
// took place, false indicates the key was already present.
|
||||
template <class Collection, class Key, class Value>
|
||||
bool InsertIfNotPresent(Collection * const collection,
|
||||
const Key& key, const Value& value) {
|
||||
pair<typename Collection::iterator, bool> ret =
|
||||
collection->insert(typename Collection::value_type(key, value));
|
||||
return ret.second;
|
||||
}
|
||||
|
||||
} // namespace protobuf
|
||||
} // namespace google
|
||||
|
||||
#endif // GOOGLE_PROTOBUF_STUBS_MAP_UTIL_H__
|
||||
@ -1,123 +0,0 @@
|
||||
// Protocol Buffers - Google's data interchange format
|
||||
// Copyright 2008 Google Inc. All rights reserved.
|
||||
// http://code.google.com/p/protobuf/
|
||||
//
|
||||
// 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.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// 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.
|
||||
|
||||
// Author: kenton@google.com (Kenton Varda)
|
||||
//
|
||||
// emulates google3/base/once.h
|
||||
//
|
||||
// This header is intended to be included only by internal .cc files and
|
||||
// generated .pb.cc files. Users should not use this directly.
|
||||
//
|
||||
// This is basically a portable version of pthread_once().
|
||||
//
|
||||
// This header declares three things:
|
||||
// * A type called ProtobufOnceType.
|
||||
// * A macro GOOGLE_PROTOBUF_DECLARE_ONCE() which declares a variable of type
|
||||
// ProtobufOnceType. This is the only legal way to declare such a variable.
|
||||
// The macro may only be used at the global scope (you cannot create local
|
||||
// or class member variables of this type).
|
||||
// * A function GogoleOnceInit(ProtobufOnceType* once, void (*init_func)()).
|
||||
// This function, when invoked multiple times given the same ProtobufOnceType
|
||||
// object, will invoke init_func on the first call only, and will make sure
|
||||
// none of the calls return before that first call to init_func has finished.
|
||||
//
|
||||
// This implements a way to perform lazy initialization. It's more efficient
|
||||
// than using mutexes as no lock is needed if initialization has already
|
||||
// happened.
|
||||
//
|
||||
// Example usage:
|
||||
// void Init();
|
||||
// GOOGLE_PROTOBUF_DECLARE_ONCE(once_init);
|
||||
//
|
||||
// // Calls Init() exactly once.
|
||||
// void InitOnce() {
|
||||
// GoogleOnceInit(&once_init, &Init);
|
||||
// }
|
||||
//
|
||||
// Note that if GoogleOnceInit() is called before main() has begun, it must
|
||||
// only be called by the thread that will eventually call main() -- that is,
|
||||
// the thread that performs dynamic initialization. In general this is a safe
|
||||
// assumption since people don't usually construct threads before main() starts,
|
||||
// but it is technically not guaranteed. Unfortunately, Win32 provides no way
|
||||
// whatsoever to statically-initialize its synchronization primitives, so our
|
||||
// only choice is to assume that dynamic initialization is single-threaded.
|
||||
|
||||
#ifndef GOOGLE_PROTOBUF_STUBS_ONCE_H__
|
||||
#define GOOGLE_PROTOBUF_STUBS_ONCE_H__
|
||||
|
||||
#include <google/protobuf/stubs/common.h>
|
||||
|
||||
#ifndef _WIN32
|
||||
#include <pthread.h>
|
||||
#endif
|
||||
|
||||
namespace google {
|
||||
namespace protobuf {
|
||||
|
||||
#ifdef _WIN32
|
||||
|
||||
struct ProtobufOnceInternal;
|
||||
|
||||
struct LIBPROTOBUF_EXPORT ProtobufOnceType {
|
||||
ProtobufOnceType();
|
||||
~ProtobufOnceType();
|
||||
void Init(void (*init_func)());
|
||||
|
||||
volatile bool initialized_;
|
||||
ProtobufOnceInternal* internal_;
|
||||
};
|
||||
|
||||
#define GOOGLE_PROTOBUF_DECLARE_ONCE(NAME) \
|
||||
::google::protobuf::ProtobufOnceType NAME
|
||||
|
||||
inline void GoogleOnceInit(ProtobufOnceType* once, void (*init_func)()) {
|
||||
// Note: Double-checked locking is safe on x86.
|
||||
if (!once->initialized_) {
|
||||
once->Init(init_func);
|
||||
}
|
||||
}
|
||||
|
||||
#else
|
||||
|
||||
typedef pthread_once_t ProtobufOnceType;
|
||||
|
||||
#define GOOGLE_PROTOBUF_DECLARE_ONCE(NAME) \
|
||||
pthread_once_t NAME = PTHREAD_ONCE_INIT
|
||||
|
||||
inline void GoogleOnceInit(ProtobufOnceType* once, void (*init_func)()) {
|
||||
pthread_once(once, init_func);
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
} // namespace protobuf
|
||||
} // namespace google
|
||||
|
||||
#endif // GOOGLE_PROTOBUF_STUBS_ONCE_H__
|
||||
File diff suppressed because it is too large
Load Diff
@ -1,457 +0,0 @@
|
||||
// Protocol Buffers - Google's data interchange format
|
||||
// Copyright 2008 Google Inc. All rights reserved.
|
||||
// http://code.google.com/p/protobuf/
|
||||
//
|
||||
// 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.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// 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.
|
||||
|
||||
// from google3/strings/strutil.h
|
||||
|
||||
#ifndef GOOGLE_PROTOBUF_STUBS_STRUTIL_H__
|
||||
#define GOOGLE_PROTOBUF_STUBS_STRUTIL_H__
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <vector>
|
||||
#include <google/protobuf/stubs/common.h>
|
||||
|
||||
namespace google {
|
||||
namespace protobuf {
|
||||
|
||||
#ifdef _MSC_VER
|
||||
#define strtoll _strtoi64
|
||||
#define strtoull _strtoui64
|
||||
#elif defined(__DECCXX) && defined(__osf__)
|
||||
// HP C++ on Tru64 does not have strtoll, but strtol is already 64-bit.
|
||||
#define strtoll strtol
|
||||
#define strtoull strtoul
|
||||
#endif
|
||||
|
||||
// ----------------------------------------------------------------------
|
||||
// ascii_isalnum()
|
||||
// Check if an ASCII character is alphanumeric. We can't use ctype's
|
||||
// isalnum() because it is affected by locale. This function is applied
|
||||
// to identifiers in the protocol buffer language, not to natural-language
|
||||
// strings, so locale should not be taken into account.
|
||||
// ascii_isdigit()
|
||||
// Like above, but only accepts digits.
|
||||
// ----------------------------------------------------------------------
|
||||
|
||||
inline bool ascii_isalnum(char c) {
|
||||
return ('a' <= c && c <= 'z') ||
|
||||
('A' <= c && c <= 'Z') ||
|
||||
('0' <= c && c <= '9');
|
||||
}
|
||||
|
||||
inline bool ascii_isdigit(char c) {
|
||||
return ('0' <= c && c <= '9');
|
||||
}
|
||||
|
||||
// ----------------------------------------------------------------------
|
||||
// HasPrefixString()
|
||||
// Check if a string begins with a given prefix.
|
||||
// StripPrefixString()
|
||||
// Given a string and a putative prefix, returns the string minus the
|
||||
// prefix string if the prefix matches, otherwise the original
|
||||
// string.
|
||||
// ----------------------------------------------------------------------
|
||||
inline bool HasPrefixString(const string& str,
|
||||
const string& prefix) {
|
||||
return str.size() >= prefix.size() &&
|
||||
str.compare(0, prefix.size(), prefix) == 0;
|
||||
}
|
||||
|
||||
inline string StripPrefixString(const string& str, const string& prefix) {
|
||||
if (HasPrefixString(str, prefix)) {
|
||||
return str.substr(prefix.size());
|
||||
} else {
|
||||
return str;
|
||||
}
|
||||
}
|
||||
|
||||
// ----------------------------------------------------------------------
|
||||
// HasSuffixString()
|
||||
// Return true if str ends in suffix.
|
||||
// StripSuffixString()
|
||||
// Given a string and a putative suffix, returns the string minus the
|
||||
// suffix string if the suffix matches, otherwise the original
|
||||
// string.
|
||||
// ----------------------------------------------------------------------
|
||||
inline bool HasSuffixString(const string& str,
|
||||
const string& suffix) {
|
||||
return str.size() >= suffix.size() &&
|
||||
str.compare(str.size() - suffix.size(), suffix.size(), suffix) == 0;
|
||||
}
|
||||
|
||||
inline string StripSuffixString(const string& str, const string& suffix) {
|
||||
if (HasSuffixString(str, suffix)) {
|
||||
return str.substr(0, str.size() - suffix.size());
|
||||
} else {
|
||||
return str;
|
||||
}
|
||||
}
|
||||
|
||||
// ----------------------------------------------------------------------
|
||||
// StripString
|
||||
// Replaces any occurrence of the character 'remove' (or the characters
|
||||
// in 'remove') with the character 'replacewith'.
|
||||
// Good for keeping html characters or protocol characters (\t) out
|
||||
// of places where they might cause a problem.
|
||||
// ----------------------------------------------------------------------
|
||||
LIBPROTOBUF_EXPORT void StripString(string* s, const char* remove,
|
||||
char replacewith);
|
||||
|
||||
// ----------------------------------------------------------------------
|
||||
// LowerString()
|
||||
// UpperString()
|
||||
// Convert the characters in "s" to lowercase or uppercase. ASCII-only:
|
||||
// these functions intentionally ignore locale because they are applied to
|
||||
// identifiers used in the Protocol Buffer language, not to natural-language
|
||||
// strings.
|
||||
// ----------------------------------------------------------------------
|
||||
|
||||
inline void LowerString(string * s) {
|
||||
string::iterator end = s->end();
|
||||
for (string::iterator i = s->begin(); i != end; ++i) {
|
||||
// tolower() changes based on locale. We don't want this!
|
||||
if ('A' <= *i && *i <= 'Z') *i += 'a' - 'A';
|
||||
}
|
||||
}
|
||||
|
||||
inline void UpperString(string * s) {
|
||||
string::iterator end = s->end();
|
||||
for (string::iterator i = s->begin(); i != end; ++i) {
|
||||
// toupper() changes based on locale. We don't want this!
|
||||
if ('a' <= *i && *i <= 'z') *i += 'A' - 'a';
|
||||
}
|
||||
}
|
||||
|
||||
// ----------------------------------------------------------------------
|
||||
// StringReplace()
|
||||
// Give me a string and two patterns "old" and "new", and I replace
|
||||
// the first instance of "old" in the string with "new", if it
|
||||
// exists. RETURN a new string, regardless of whether the replacement
|
||||
// happened or not.
|
||||
// ----------------------------------------------------------------------
|
||||
|
||||
LIBPROTOBUF_EXPORT string StringReplace(const string& s, const string& oldsub,
|
||||
const string& newsub, bool replace_all);
|
||||
|
||||
// ----------------------------------------------------------------------
|
||||
// SplitStringUsing()
|
||||
// Split a string using a character delimiter. Append the components
|
||||
// to 'result'. If there are consecutive delimiters, this function skips
|
||||
// over all of them.
|
||||
// ----------------------------------------------------------------------
|
||||
LIBPROTOBUF_EXPORT void SplitStringUsing(const string& full, const char* delim,
|
||||
vector<string>* res);
|
||||
|
||||
// ----------------------------------------------------------------------
|
||||
// JoinStrings()
|
||||
// These methods concatenate a vector of strings into a C++ string, using
|
||||
// the C-string "delim" as a separator between components. There are two
|
||||
// flavors of the function, one flavor returns the concatenated string,
|
||||
// another takes a pointer to the target string. In the latter case the
|
||||
// target string is cleared and overwritten.
|
||||
// ----------------------------------------------------------------------
|
||||
LIBPROTOBUF_EXPORT void JoinStrings(const vector<string>& components,
|
||||
const char* delim, string* result);
|
||||
|
||||
inline string JoinStrings(const vector<string>& components,
|
||||
const char* delim) {
|
||||
string result;
|
||||
JoinStrings(components, delim, &result);
|
||||
return result;
|
||||
}
|
||||
|
||||
// ----------------------------------------------------------------------
|
||||
// UnescapeCEscapeSequences()
|
||||
// Copies "source" to "dest", rewriting C-style escape sequences
|
||||
// -- '\n', '\r', '\\', '\ooo', etc -- to their ASCII
|
||||
// equivalents. "dest" must be sufficiently large to hold all
|
||||
// the characters in the rewritten string (i.e. at least as large
|
||||
// as strlen(source) + 1 should be safe, since the replacements
|
||||
// are always shorter than the original escaped sequences). It's
|
||||
// safe for source and dest to be the same. RETURNS the length
|
||||
// of dest.
|
||||
//
|
||||
// It allows hex sequences \xhh, or generally \xhhhhh with an
|
||||
// arbitrary number of hex digits, but all of them together must
|
||||
// specify a value of a single byte (e.g. \x0045 is equivalent
|
||||
// to \x45, and \x1234 is erroneous).
|
||||
//
|
||||
// It also allows escape sequences of the form \uhhhh (exactly four
|
||||
// hex digits, upper or lower case) or \Uhhhhhhhh (exactly eight
|
||||
// hex digits, upper or lower case) to specify a Unicode code
|
||||
// point. The dest array will contain the UTF8-encoded version of
|
||||
// that code-point (e.g., if source contains \u2019, then dest will
|
||||
// contain the three bytes 0xE2, 0x80, and 0x99).
|
||||
//
|
||||
// Errors: In the first form of the call, errors are reported with
|
||||
// LOG(ERROR). The same is true for the second form of the call if
|
||||
// the pointer to the string vector is NULL; otherwise, error
|
||||
// messages are stored in the vector. In either case, the effect on
|
||||
// the dest array is not defined, but rest of the source will be
|
||||
// processed.
|
||||
// ----------------------------------------------------------------------
|
||||
|
||||
LIBPROTOBUF_EXPORT int UnescapeCEscapeSequences(const char* source, char* dest);
|
||||
LIBPROTOBUF_EXPORT int UnescapeCEscapeSequences(const char* source, char* dest,
|
||||
vector<string> *errors);
|
||||
|
||||
// ----------------------------------------------------------------------
|
||||
// UnescapeCEscapeString()
|
||||
// This does the same thing as UnescapeCEscapeSequences, but creates
|
||||
// a new string. The caller does not need to worry about allocating
|
||||
// a dest buffer. This should be used for non performance critical
|
||||
// tasks such as printing debug messages. It is safe for src and dest
|
||||
// to be the same.
|
||||
//
|
||||
// The second call stores its errors in a supplied string vector.
|
||||
// If the string vector pointer is NULL, it reports the errors with LOG().
|
||||
//
|
||||
// In the first and second calls, the length of dest is returned. In the
|
||||
// the third call, the new string is returned.
|
||||
// ----------------------------------------------------------------------
|
||||
|
||||
LIBPROTOBUF_EXPORT int UnescapeCEscapeString(const string& src, string* dest);
|
||||
LIBPROTOBUF_EXPORT int UnescapeCEscapeString(const string& src, string* dest,
|
||||
vector<string> *errors);
|
||||
LIBPROTOBUF_EXPORT string UnescapeCEscapeString(const string& src);
|
||||
|
||||
// ----------------------------------------------------------------------
|
||||
// CEscapeString()
|
||||
// Copies 'src' to 'dest', escaping dangerous characters using
|
||||
// C-style escape sequences. This is very useful for preparing query
|
||||
// flags. 'src' and 'dest' should not overlap.
|
||||
// Returns the number of bytes written to 'dest' (not including the \0)
|
||||
// or -1 if there was insufficient space.
|
||||
//
|
||||
// Currently only \n, \r, \t, ", ', \ and !isprint() chars are escaped.
|
||||
// ----------------------------------------------------------------------
|
||||
LIBPROTOBUF_EXPORT int CEscapeString(const char* src, int src_len,
|
||||
char* dest, int dest_len);
|
||||
|
||||
// ----------------------------------------------------------------------
|
||||
// CEscape()
|
||||
// More convenient form of CEscapeString: returns result as a "string".
|
||||
// This version is slower than CEscapeString() because it does more
|
||||
// allocation. However, it is much more convenient to use in
|
||||
// non-speed-critical code like logging messages etc.
|
||||
// ----------------------------------------------------------------------
|
||||
LIBPROTOBUF_EXPORT string CEscape(const string& src);
|
||||
|
||||
namespace strings {
|
||||
// Like CEscape() but does not escape bytes with the upper bit set.
|
||||
LIBPROTOBUF_EXPORT string Utf8SafeCEscape(const string& src);
|
||||
|
||||
// Like CEscape() but uses hex (\x) escapes instead of octals.
|
||||
LIBPROTOBUF_EXPORT string CHexEscape(const string& src);
|
||||
} // namespace strings
|
||||
|
||||
// ----------------------------------------------------------------------
|
||||
// strto32()
|
||||
// strtou32()
|
||||
// strto64()
|
||||
// strtou64()
|
||||
// Architecture-neutral plug compatible replacements for strtol() and
|
||||
// strtoul(). Long's have different lengths on ILP-32 and LP-64
|
||||
// platforms, so using these is safer, from the point of view of
|
||||
// overflow behavior, than using the standard libc functions.
|
||||
// ----------------------------------------------------------------------
|
||||
LIBPROTOBUF_EXPORT int32 strto32_adaptor(const char *nptr, char **endptr,
|
||||
int base);
|
||||
LIBPROTOBUF_EXPORT uint32 strtou32_adaptor(const char *nptr, char **endptr,
|
||||
int base);
|
||||
|
||||
inline int32 strto32(const char *nptr, char **endptr, int base) {
|
||||
if (sizeof(int32) == sizeof(long))
|
||||
return strtol(nptr, endptr, base);
|
||||
else
|
||||
return strto32_adaptor(nptr, endptr, base);
|
||||
}
|
||||
|
||||
inline uint32 strtou32(const char *nptr, char **endptr, int base) {
|
||||
if (sizeof(uint32) == sizeof(unsigned long))
|
||||
return strtoul(nptr, endptr, base);
|
||||
else
|
||||
return strtou32_adaptor(nptr, endptr, base);
|
||||
}
|
||||
|
||||
// For now, long long is 64-bit on all the platforms we care about, so these
|
||||
// functions can simply pass the call to strto[u]ll.
|
||||
inline int64 strto64(const char *nptr, char **endptr, int base) {
|
||||
GOOGLE_COMPILE_ASSERT(sizeof(int64) == sizeof(long long),
|
||||
sizeof_int64_is_not_sizeof_long_long);
|
||||
return strtoll(nptr, endptr, base);
|
||||
}
|
||||
|
||||
inline uint64 strtou64(const char *nptr, char **endptr, int base) {
|
||||
GOOGLE_COMPILE_ASSERT(sizeof(uint64) == sizeof(unsigned long long),
|
||||
sizeof_uint64_is_not_sizeof_long_long);
|
||||
return strtoull(nptr, endptr, base);
|
||||
}
|
||||
|
||||
// ----------------------------------------------------------------------
|
||||
// FastIntToBuffer()
|
||||
// FastHexToBuffer()
|
||||
// FastHex64ToBuffer()
|
||||
// FastHex32ToBuffer()
|
||||
// FastTimeToBuffer()
|
||||
// These are intended for speed. FastIntToBuffer() assumes the
|
||||
// integer is non-negative. FastHexToBuffer() puts output in
|
||||
// hex rather than decimal. FastTimeToBuffer() puts the output
|
||||
// into RFC822 format.
|
||||
//
|
||||
// FastHex64ToBuffer() puts a 64-bit unsigned value in hex-format,
|
||||
// padded to exactly 16 bytes (plus one byte for '\0')
|
||||
//
|
||||
// FastHex32ToBuffer() puts a 32-bit unsigned value in hex-format,
|
||||
// padded to exactly 8 bytes (plus one byte for '\0')
|
||||
//
|
||||
// All functions take the output buffer as an arg.
|
||||
// They all return a pointer to the beginning of the output,
|
||||
// which may not be the beginning of the input buffer.
|
||||
// ----------------------------------------------------------------------
|
||||
|
||||
// Suggested buffer size for FastToBuffer functions. Also works with
|
||||
// DoubleToBuffer() and FloatToBuffer().
|
||||
static const int kFastToBufferSize = 32;
|
||||
|
||||
LIBPROTOBUF_EXPORT char* FastInt32ToBuffer(int32 i, char* buffer);
|
||||
LIBPROTOBUF_EXPORT char* FastInt64ToBuffer(int64 i, char* buffer);
|
||||
char* FastUInt32ToBuffer(uint32 i, char* buffer); // inline below
|
||||
char* FastUInt64ToBuffer(uint64 i, char* buffer); // inline below
|
||||
LIBPROTOBUF_EXPORT char* FastHexToBuffer(int i, char* buffer);
|
||||
LIBPROTOBUF_EXPORT char* FastHex64ToBuffer(uint64 i, char* buffer);
|
||||
LIBPROTOBUF_EXPORT char* FastHex32ToBuffer(uint32 i, char* buffer);
|
||||
|
||||
// at least 22 bytes long
|
||||
inline char* FastIntToBuffer(int i, char* buffer) {
|
||||
return (sizeof(i) == 4 ?
|
||||
FastInt32ToBuffer(i, buffer) : FastInt64ToBuffer(i, buffer));
|
||||
}
|
||||
inline char* FastUIntToBuffer(unsigned int i, char* buffer) {
|
||||
return (sizeof(i) == 4 ?
|
||||
FastUInt32ToBuffer(i, buffer) : FastUInt64ToBuffer(i, buffer));
|
||||
}
|
||||
inline char* FastLongToBuffer(long i, char* buffer) {
|
||||
return (sizeof(i) == 4 ?
|
||||
FastInt32ToBuffer(i, buffer) : FastInt64ToBuffer(i, buffer));
|
||||
}
|
||||
inline char* FastULongToBuffer(unsigned long i, char* buffer) {
|
||||
return (sizeof(i) == 4 ?
|
||||
FastUInt32ToBuffer(i, buffer) : FastUInt64ToBuffer(i, buffer));
|
||||
}
|
||||
|
||||
// ----------------------------------------------------------------------
|
||||
// FastInt32ToBufferLeft()
|
||||
// FastUInt32ToBufferLeft()
|
||||
// FastInt64ToBufferLeft()
|
||||
// FastUInt64ToBufferLeft()
|
||||
//
|
||||
// Like the Fast*ToBuffer() functions above, these are intended for speed.
|
||||
// Unlike the Fast*ToBuffer() functions, however, these functions write
|
||||
// their output to the beginning of the buffer (hence the name, as the
|
||||
// output is left-aligned). The caller is responsible for ensuring that
|
||||
// the buffer has enough space to hold the output.
|
||||
//
|
||||
// Returns a pointer to the end of the string (i.e. the null character
|
||||
// terminating the string).
|
||||
// ----------------------------------------------------------------------
|
||||
|
||||
LIBPROTOBUF_EXPORT char* FastInt32ToBufferLeft(int32 i, char* buffer);
|
||||
LIBPROTOBUF_EXPORT char* FastUInt32ToBufferLeft(uint32 i, char* buffer);
|
||||
LIBPROTOBUF_EXPORT char* FastInt64ToBufferLeft(int64 i, char* buffer);
|
||||
LIBPROTOBUF_EXPORT char* FastUInt64ToBufferLeft(uint64 i, char* buffer);
|
||||
|
||||
// Just define these in terms of the above.
|
||||
inline char* FastUInt32ToBuffer(uint32 i, char* buffer) {
|
||||
FastUInt32ToBufferLeft(i, buffer);
|
||||
return buffer;
|
||||
}
|
||||
inline char* FastUInt64ToBuffer(uint64 i, char* buffer) {
|
||||
FastUInt64ToBufferLeft(i, buffer);
|
||||
return buffer;
|
||||
}
|
||||
|
||||
// ----------------------------------------------------------------------
|
||||
// SimpleItoa()
|
||||
// Description: converts an integer to a string.
|
||||
//
|
||||
// Return value: string
|
||||
// ----------------------------------------------------------------------
|
||||
LIBPROTOBUF_EXPORT string SimpleItoa(int i);
|
||||
LIBPROTOBUF_EXPORT string SimpleItoa(unsigned int i);
|
||||
LIBPROTOBUF_EXPORT string SimpleItoa(long i);
|
||||
LIBPROTOBUF_EXPORT string SimpleItoa(unsigned long i);
|
||||
LIBPROTOBUF_EXPORT string SimpleItoa(long long i);
|
||||
LIBPROTOBUF_EXPORT string SimpleItoa(unsigned long long i);
|
||||
|
||||
// ----------------------------------------------------------------------
|
||||
// SimpleDtoa()
|
||||
// SimpleFtoa()
|
||||
// DoubleToBuffer()
|
||||
// FloatToBuffer()
|
||||
// Description: converts a double or float to a string which, if
|
||||
// passed to NoLocaleStrtod(), will produce the exact same original double
|
||||
// (except in case of NaN; all NaNs are considered the same value).
|
||||
// We try to keep the string short but it's not guaranteed to be as
|
||||
// short as possible.
|
||||
//
|
||||
// DoubleToBuffer() and FloatToBuffer() write the text to the given
|
||||
// buffer and return it. The buffer must be at least
|
||||
// kDoubleToBufferSize bytes for doubles and kFloatToBufferSize
|
||||
// bytes for floats. kFastToBufferSize is also guaranteed to be large
|
||||
// enough to hold either.
|
||||
//
|
||||
// Return value: string
|
||||
// ----------------------------------------------------------------------
|
||||
LIBPROTOBUF_EXPORT string SimpleDtoa(double value);
|
||||
LIBPROTOBUF_EXPORT string SimpleFtoa(float value);
|
||||
|
||||
LIBPROTOBUF_EXPORT char* DoubleToBuffer(double i, char* buffer);
|
||||
LIBPROTOBUF_EXPORT char* FloatToBuffer(float i, char* buffer);
|
||||
|
||||
// In practice, doubles should never need more than 24 bytes and floats
|
||||
// should never need more than 14 (including null terminators), but we
|
||||
// overestimate to be safe.
|
||||
static const int kDoubleToBufferSize = 32;
|
||||
static const int kFloatToBufferSize = 24;
|
||||
|
||||
// ----------------------------------------------------------------------
|
||||
// NoLocaleStrtod()
|
||||
// Exactly like strtod(), except it always behaves as if in the "C"
|
||||
// locale (i.e. decimal points must be '.'s).
|
||||
// ----------------------------------------------------------------------
|
||||
|
||||
LIBPROTOBUF_EXPORT double NoLocaleStrtod(const char* text, char** endptr);
|
||||
|
||||
} // namespace protobuf
|
||||
} // namespace google
|
||||
|
||||
#endif // GOOGLE_PROTOBUF_STUBS_STRUTIL_H__
|
||||
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@ -1,285 +0,0 @@
|
||||
// Protocol Buffers - Google's data interchange format
|
||||
// Copyright 2008 Google Inc. All rights reserved.
|
||||
// http://code.google.com/p/protobuf/
|
||||
//
|
||||
// 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.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// 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.
|
||||
|
||||
// Author: jschorr@google.com (Joseph Schorr)
|
||||
// Based on original Protocol Buffers design by
|
||||
// Sanjay Ghemawat, Jeff Dean, and others.
|
||||
//
|
||||
// Utilities for printing and parsing protocol messages in a human-readable,
|
||||
// text-based format.
|
||||
|
||||
#ifndef GOOGLE_PROTOBUF_TEXT_FORMAT_H__
|
||||
#define GOOGLE_PROTOBUF_TEXT_FORMAT_H__
|
||||
|
||||
#include <string>
|
||||
#include <google/protobuf/message.h>
|
||||
#include <google/protobuf/descriptor.h>
|
||||
|
||||
namespace google {
|
||||
namespace protobuf {
|
||||
|
||||
namespace io {
|
||||
class ErrorCollector; // tokenizer.h
|
||||
}
|
||||
|
||||
// This class implements protocol buffer text format. Printing and parsing
|
||||
// protocol messages in text format is useful for debugging and human editing
|
||||
// of messages.
|
||||
//
|
||||
// This class is really a namespace that contains only static methods.
|
||||
class LIBPROTOBUF_EXPORT TextFormat {
|
||||
public:
|
||||
// Outputs a textual representation of the given message to the given
|
||||
// output stream.
|
||||
static bool Print(const Message& message, io::ZeroCopyOutputStream* output);
|
||||
|
||||
// Print the fields in an UnknownFieldSet. They are printed by tag number
|
||||
// only. Embedded messages are heuristically identified by attempting to
|
||||
// parse them.
|
||||
static bool PrintUnknownFields(const UnknownFieldSet& unknown_fields,
|
||||
io::ZeroCopyOutputStream* output);
|
||||
|
||||
// Like Print(), but outputs directly to a string.
|
||||
static bool PrintToString(const Message& message, string* output);
|
||||
|
||||
// Like PrintUnknownFields(), but outputs directly to a string.
|
||||
static bool PrintUnknownFieldsToString(const UnknownFieldSet& unknown_fields,
|
||||
string* output);
|
||||
|
||||
// Outputs a textual representation of the value of the field supplied on
|
||||
// the message supplied. For non-repeated fields, an index of -1 must
|
||||
// be supplied. Note that this method will print the default value for a
|
||||
// field if it is not set.
|
||||
static void PrintFieldValueToString(const Message& message,
|
||||
const FieldDescriptor* field,
|
||||
int index,
|
||||
string* output);
|
||||
|
||||
// Class for those users which require more fine-grained control over how
|
||||
// a protobuffer message is printed out.
|
||||
class LIBPROTOBUF_EXPORT Printer {
|
||||
public:
|
||||
Printer();
|
||||
~Printer();
|
||||
|
||||
// Like TextFormat::Print
|
||||
bool Print(const Message& message, io::ZeroCopyOutputStream* output) const;
|
||||
// Like TextFormat::PrintUnknownFields
|
||||
bool PrintUnknownFields(const UnknownFieldSet& unknown_fields,
|
||||
io::ZeroCopyOutputStream* output) const;
|
||||
// Like TextFormat::PrintToString
|
||||
bool PrintToString(const Message& message, string* output) const;
|
||||
// Like TextFormat::PrintUnknownFieldsToString
|
||||
bool PrintUnknownFieldsToString(const UnknownFieldSet& unknown_fields,
|
||||
string* output) const;
|
||||
// Like TextFormat::PrintFieldValueToString
|
||||
void PrintFieldValueToString(const Message& message,
|
||||
const FieldDescriptor* field,
|
||||
int index,
|
||||
string* output) const;
|
||||
|
||||
// Adjust the initial indent level of all output. Each indent level is
|
||||
// equal to two spaces.
|
||||
void SetInitialIndentLevel(int indent_level) {
|
||||
initial_indent_level_ = indent_level;
|
||||
}
|
||||
|
||||
// If printing in single line mode, then the entire message will be output
|
||||
// on a single line with no line breaks.
|
||||
void SetSingleLineMode(bool single_line_mode) {
|
||||
single_line_mode_ = single_line_mode;
|
||||
}
|
||||
|
||||
// Set true to print repeated primitives in a format like:
|
||||
// field_name: [1, 2, 3, 4]
|
||||
// instead of printing each value on its own line. Short format applies
|
||||
// only to primitive values -- i.e. everything except strings and
|
||||
// sub-messages/groups.
|
||||
void SetUseShortRepeatedPrimitives(bool use_short_repeated_primitives) {
|
||||
use_short_repeated_primitives_ = use_short_repeated_primitives;
|
||||
}
|
||||
|
||||
// Set true to output UTF-8 instead of ASCII. The only difference
|
||||
// is that bytes >= 0x80 in string fields will not be escaped,
|
||||
// because they are assumed to be part of UTF-8 multi-byte
|
||||
// sequences.
|
||||
void SetUseUtf8StringEscaping(bool as_utf8) {
|
||||
utf8_string_escaping_ = as_utf8;
|
||||
}
|
||||
|
||||
private:
|
||||
// Forward declaration of an internal class used to print the text
|
||||
// output to the OutputStream (see text_format.cc for implementation).
|
||||
class TextGenerator;
|
||||
|
||||
// Internal Print method, used for writing to the OutputStream via
|
||||
// the TextGenerator class.
|
||||
void Print(const Message& message,
|
||||
TextGenerator& generator) const;
|
||||
|
||||
// Print a single field.
|
||||
void PrintField(const Message& message,
|
||||
const Reflection* reflection,
|
||||
const FieldDescriptor* field,
|
||||
TextGenerator& generator) const;
|
||||
|
||||
// Print a repeated primitive field in short form.
|
||||
void PrintShortRepeatedField(const Message& message,
|
||||
const Reflection* reflection,
|
||||
const FieldDescriptor* field,
|
||||
TextGenerator& generator) const;
|
||||
|
||||
// Print the name of a field -- i.e. everything that comes before the
|
||||
// ':' for a single name/value pair.
|
||||
void PrintFieldName(const Message& message,
|
||||
const Reflection* reflection,
|
||||
const FieldDescriptor* field,
|
||||
TextGenerator& generator) const;
|
||||
|
||||
// Outputs a textual representation of the value of the field supplied on
|
||||
// the message supplied or the default value if not set.
|
||||
void PrintFieldValue(const Message& message,
|
||||
const Reflection* reflection,
|
||||
const FieldDescriptor* field,
|
||||
int index,
|
||||
TextGenerator& generator) const;
|
||||
|
||||
// Print the fields in an UnknownFieldSet. They are printed by tag number
|
||||
// only. Embedded messages are heuristically identified by attempting to
|
||||
// parse them.
|
||||
void PrintUnknownFields(const UnknownFieldSet& unknown_fields,
|
||||
TextGenerator& generator) const;
|
||||
|
||||
int initial_indent_level_;
|
||||
|
||||
bool single_line_mode_;
|
||||
|
||||
bool use_short_repeated_primitives_;
|
||||
|
||||
bool utf8_string_escaping_;
|
||||
};
|
||||
|
||||
// Parses a text-format protocol message from the given input stream to
|
||||
// the given message object. This function parses the format written
|
||||
// by Print().
|
||||
static bool Parse(io::ZeroCopyInputStream* input, Message* output);
|
||||
// Like Parse(), but reads directly from a string.
|
||||
static bool ParseFromString(const string& input, Message* output);
|
||||
|
||||
// Like Parse(), but the data is merged into the given message, as if
|
||||
// using Message::MergeFrom().
|
||||
static bool Merge(io::ZeroCopyInputStream* input, Message* output);
|
||||
// Like Merge(), but reads directly from a string.
|
||||
static bool MergeFromString(const string& input, Message* output);
|
||||
|
||||
// Parse the given text as a single field value and store it into the
|
||||
// given field of the given message. If the field is a repeated field,
|
||||
// the new value will be added to the end
|
||||
static bool ParseFieldValueFromString(const string& input,
|
||||
const FieldDescriptor* field,
|
||||
Message* message);
|
||||
|
||||
// Interface that TextFormat::Parser can use to find extensions.
|
||||
// This class may be extended in the future to find more information
|
||||
// like fields, etc.
|
||||
class LIBPROTOBUF_EXPORT Finder {
|
||||
public:
|
||||
virtual ~Finder();
|
||||
|
||||
// Try to find an extension of *message by fully-qualified field
|
||||
// name. Returns NULL if no extension is known for this name or number.
|
||||
virtual const FieldDescriptor* FindExtension(
|
||||
Message* message,
|
||||
const string& name) const = 0;
|
||||
};
|
||||
|
||||
// For more control over parsing, use this class.
|
||||
class LIBPROTOBUF_EXPORT Parser {
|
||||
public:
|
||||
Parser();
|
||||
~Parser();
|
||||
|
||||
// Like TextFormat::Parse().
|
||||
bool Parse(io::ZeroCopyInputStream* input, Message* output);
|
||||
// Like TextFormat::ParseFromString().
|
||||
bool ParseFromString(const string& input, Message* output);
|
||||
// Like TextFormat::Merge().
|
||||
bool Merge(io::ZeroCopyInputStream* input, Message* output);
|
||||
// Like TextFormat::MergeFromString().
|
||||
bool MergeFromString(const string& input, Message* output);
|
||||
|
||||
// Set where to report parse errors. If NULL (the default), errors will
|
||||
// be printed to stderr.
|
||||
void RecordErrorsTo(io::ErrorCollector* error_collector) {
|
||||
error_collector_ = error_collector;
|
||||
}
|
||||
|
||||
// Set how parser finds extensions. If NULL (the default), the
|
||||
// parser will use the standard Reflection object associated with
|
||||
// the message being parsed.
|
||||
void SetFinder(Finder* finder) {
|
||||
finder_ = finder;
|
||||
}
|
||||
|
||||
// Normally parsing fails if, after parsing, output->IsInitialized()
|
||||
// returns false. Call AllowPartialMessage(true) to skip this check.
|
||||
void AllowPartialMessage(bool allow) {
|
||||
allow_partial_ = allow;
|
||||
}
|
||||
|
||||
// Like TextFormat::ParseFieldValueFromString
|
||||
bool ParseFieldValueFromString(const string& input,
|
||||
const FieldDescriptor* field,
|
||||
Message* output);
|
||||
|
||||
private:
|
||||
// Forward declaration of an internal class used to parse text
|
||||
// representations (see text_format.cc for implementation).
|
||||
class ParserImpl;
|
||||
|
||||
// Like TextFormat::Merge(). The provided implementation is used
|
||||
// to do the parsing.
|
||||
bool MergeUsingImpl(io::ZeroCopyInputStream* input,
|
||||
Message* output,
|
||||
ParserImpl* parser_impl);
|
||||
|
||||
io::ErrorCollector* error_collector_;
|
||||
Finder* finder_;
|
||||
bool allow_partial_;
|
||||
};
|
||||
|
||||
private:
|
||||
GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(TextFormat);
|
||||
};
|
||||
|
||||
} // namespace protobuf
|
||||
|
||||
} // namespace google
|
||||
#endif // GOOGLE_PROTOBUF_TEXT_FORMAT_H__
|
||||
@ -1,204 +0,0 @@
|
||||
// Protocol Buffers - Google's data interchange format
|
||||
// Copyright 2008 Google Inc. All rights reserved.
|
||||
// http://code.google.com/p/protobuf/
|
||||
//
|
||||
// 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.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// 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.
|
||||
|
||||
// Author: kenton@google.com (Kenton Varda)
|
||||
// Based on original Protocol Buffers design by
|
||||
// Sanjay Ghemawat, Jeff Dean, and others.
|
||||
|
||||
#include <google/protobuf/stubs/common.h>
|
||||
#include <google/protobuf/unknown_field_set.h>
|
||||
#include <google/protobuf/stubs/stl_util-inl.h>
|
||||
#include <google/protobuf/io/coded_stream.h>
|
||||
#include <google/protobuf/io/zero_copy_stream.h>
|
||||
#include <google/protobuf/io/zero_copy_stream_impl.h>
|
||||
#include <google/protobuf/wire_format.h>
|
||||
|
||||
namespace google {
|
||||
namespace protobuf {
|
||||
|
||||
UnknownFieldSet::UnknownFieldSet()
|
||||
: fields_(NULL) {}
|
||||
|
||||
UnknownFieldSet::~UnknownFieldSet() {
|
||||
Clear();
|
||||
delete fields_;
|
||||
}
|
||||
|
||||
void UnknownFieldSet::ClearFallback() {
|
||||
GOOGLE_DCHECK(fields_ != NULL);
|
||||
for (int i = 0; i < fields_->size(); i++) {
|
||||
(*fields_)[i].Delete();
|
||||
}
|
||||
fields_->clear();
|
||||
}
|
||||
|
||||
void UnknownFieldSet::MergeFrom(const UnknownFieldSet& other) {
|
||||
for (int i = 0; i < other.field_count(); i++) {
|
||||
AddField(other.field(i));
|
||||
}
|
||||
}
|
||||
|
||||
int UnknownFieldSet::SpaceUsedExcludingSelf() const {
|
||||
if (fields_ == NULL) return 0;
|
||||
|
||||
int total_size = sizeof(*fields_) + sizeof(UnknownField) * fields_->size();
|
||||
for (int i = 0; i < fields_->size(); i++) {
|
||||
const UnknownField& field = (*fields_)[i];
|
||||
switch (field.type()) {
|
||||
case UnknownField::TYPE_LENGTH_DELIMITED:
|
||||
total_size += sizeof(*field.length_delimited_) +
|
||||
internal::StringSpaceUsedExcludingSelf(*field.length_delimited_);
|
||||
break;
|
||||
case UnknownField::TYPE_GROUP:
|
||||
total_size += field.group_->SpaceUsed();
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
return total_size;
|
||||
}
|
||||
|
||||
int UnknownFieldSet::SpaceUsed() const {
|
||||
return sizeof(*this) + SpaceUsedExcludingSelf();
|
||||
}
|
||||
|
||||
void UnknownFieldSet::AddVarint(int number, uint64 value) {
|
||||
if (fields_ == NULL) fields_ = new vector<UnknownField>;
|
||||
UnknownField field;
|
||||
field.number_ = number;
|
||||
field.type_ = UnknownField::TYPE_VARINT;
|
||||
field.varint_ = value;
|
||||
fields_->push_back(field);
|
||||
}
|
||||
|
||||
void UnknownFieldSet::AddFixed32(int number, uint32 value) {
|
||||
if (fields_ == NULL) fields_ = new vector<UnknownField>;
|
||||
UnknownField field;
|
||||
field.number_ = number;
|
||||
field.type_ = UnknownField::TYPE_FIXED32;
|
||||
field.fixed32_ = value;
|
||||
fields_->push_back(field);
|
||||
}
|
||||
|
||||
void UnknownFieldSet::AddFixed64(int number, uint64 value) {
|
||||
if (fields_ == NULL) fields_ = new vector<UnknownField>;
|
||||
UnknownField field;
|
||||
field.number_ = number;
|
||||
field.type_ = UnknownField::TYPE_FIXED64;
|
||||
field.fixed64_ = value;
|
||||
fields_->push_back(field);
|
||||
}
|
||||
|
||||
string* UnknownFieldSet::AddLengthDelimited(int number) {
|
||||
if (fields_ == NULL) fields_ = new vector<UnknownField>;
|
||||
UnknownField field;
|
||||
field.number_ = number;
|
||||
field.type_ = UnknownField::TYPE_LENGTH_DELIMITED;
|
||||
field.length_delimited_ = new string;
|
||||
fields_->push_back(field);
|
||||
return field.length_delimited_;
|
||||
}
|
||||
|
||||
UnknownFieldSet* UnknownFieldSet::AddGroup(int number) {
|
||||
if (fields_ == NULL) fields_ = new vector<UnknownField>;
|
||||
UnknownField field;
|
||||
field.number_ = number;
|
||||
field.type_ = UnknownField::TYPE_GROUP;
|
||||
field.group_ = new UnknownFieldSet;
|
||||
fields_->push_back(field);
|
||||
return field.group_;
|
||||
}
|
||||
|
||||
void UnknownFieldSet::AddField(const UnknownField& field) {
|
||||
if (fields_ == NULL) fields_ = new vector<UnknownField>;
|
||||
fields_->push_back(field);
|
||||
fields_->back().DeepCopy();
|
||||
}
|
||||
|
||||
bool UnknownFieldSet::MergeFromCodedStream(io::CodedInputStream* input) {
|
||||
|
||||
UnknownFieldSet other;
|
||||
if (internal::WireFormat::SkipMessage(input, &other) &&
|
||||
input->ConsumedEntireMessage()) {
|
||||
MergeFrom(other);
|
||||
return true;
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
bool UnknownFieldSet::ParseFromCodedStream(io::CodedInputStream* input) {
|
||||
Clear();
|
||||
return MergeFromCodedStream(input);
|
||||
}
|
||||
|
||||
bool UnknownFieldSet::ParseFromZeroCopyStream(io::ZeroCopyInputStream* input) {
|
||||
io::CodedInputStream coded_input(input);
|
||||
return ParseFromCodedStream(&coded_input) &&
|
||||
coded_input.ConsumedEntireMessage();
|
||||
}
|
||||
|
||||
bool UnknownFieldSet::ParseFromArray(const void* data, int size) {
|
||||
io::ArrayInputStream input(data, size);
|
||||
return ParseFromZeroCopyStream(&input);
|
||||
}
|
||||
|
||||
void UnknownField::Delete() {
|
||||
switch (type()) {
|
||||
case UnknownField::TYPE_LENGTH_DELIMITED:
|
||||
delete length_delimited_;
|
||||
break;
|
||||
case UnknownField::TYPE_GROUP:
|
||||
delete group_;
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
void UnknownField::DeepCopy() {
|
||||
switch (type()) {
|
||||
case UnknownField::TYPE_LENGTH_DELIMITED:
|
||||
length_delimited_ = new string(*length_delimited_);
|
||||
break;
|
||||
case UnknownField::TYPE_GROUP: {
|
||||
UnknownFieldSet* group = new UnknownFieldSet;
|
||||
group->MergeFrom(*group_);
|
||||
group_ = group;
|
||||
break;
|
||||
}
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
} // namespace protobuf
|
||||
} // namespace google
|
||||
@ -1,268 +0,0 @@
|
||||
// Protocol Buffers - Google's data interchange format
|
||||
// Copyright 2008 Google Inc. All rights reserved.
|
||||
// http://code.google.com/p/protobuf/
|
||||
//
|
||||
// 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.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// 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.
|
||||
|
||||
// Author: kenton@google.com (Kenton Varda)
|
||||
// Based on original Protocol Buffers design by
|
||||
// Sanjay Ghemawat, Jeff Dean, and others.
|
||||
//
|
||||
// Contains classes used to keep track of unrecognized fields seen while
|
||||
// parsing a protocol message.
|
||||
|
||||
#ifndef GOOGLE_PROTOBUF_UNKNOWN_FIELD_SET_H__
|
||||
#define GOOGLE_PROTOBUF_UNKNOWN_FIELD_SET_H__
|
||||
|
||||
#include <string>
|
||||
#include <vector>
|
||||
#include <google/protobuf/repeated_field.h>
|
||||
|
||||
namespace google {
|
||||
namespace protobuf {
|
||||
|
||||
class Message; // message.h
|
||||
class UnknownField; // below
|
||||
|
||||
// An UnknownFieldSet contains fields that were encountered while parsing a
|
||||
// message but were not defined by its type. Keeping track of these can be
|
||||
// useful, especially in that they may be written if the message is serialized
|
||||
// again without being cleared in between. This means that software which
|
||||
// simply receives messages and forwards them to other servers does not need
|
||||
// to be updated every time a new field is added to the message definition.
|
||||
//
|
||||
// To get the UnknownFieldSet attached to any message, call
|
||||
// Reflection::GetUnknownFields().
|
||||
//
|
||||
// This class is necessarily tied to the protocol buffer wire format, unlike
|
||||
// the Reflection interface which is independent of any serialization scheme.
|
||||
class LIBPROTOBUF_EXPORT UnknownFieldSet {
|
||||
public:
|
||||
UnknownFieldSet();
|
||||
~UnknownFieldSet();
|
||||
|
||||
// Remove all fields.
|
||||
inline void Clear();
|
||||
|
||||
// Is this set empty?
|
||||
inline bool empty() const;
|
||||
|
||||
// Merge the contents of some other UnknownFieldSet with this one.
|
||||
void MergeFrom(const UnknownFieldSet& other);
|
||||
|
||||
// Swaps the contents of some other UnknownFieldSet with this one.
|
||||
inline void Swap(UnknownFieldSet* x);
|
||||
|
||||
// Computes (an estimate of) the total number of bytes currently used for
|
||||
// storing the unknown fields in memory. Does NOT include
|
||||
// sizeof(*this) in the calculation.
|
||||
int SpaceUsedExcludingSelf() const;
|
||||
|
||||
// Version of SpaceUsed() including sizeof(*this).
|
||||
int SpaceUsed() const;
|
||||
|
||||
// Returns the number of fields present in the UnknownFieldSet.
|
||||
inline int field_count() const;
|
||||
// Get a field in the set, where 0 <= index < field_count(). The fields
|
||||
// appear in the order in which they were added.
|
||||
inline const UnknownField& field(int index) const;
|
||||
// Get a mutable pointer to a field in the set, where
|
||||
// 0 <= index < field_count(). The fields appear in the order in which
|
||||
// they were added.
|
||||
inline UnknownField* mutable_field(int index);
|
||||
|
||||
// Adding fields ---------------------------------------------------
|
||||
|
||||
void AddVarint(int number, uint64 value);
|
||||
void AddFixed32(int number, uint32 value);
|
||||
void AddFixed64(int number, uint64 value);
|
||||
void AddLengthDelimited(int number, const string& value);
|
||||
string* AddLengthDelimited(int number);
|
||||
UnknownFieldSet* AddGroup(int number);
|
||||
|
||||
// Adds an unknown field from another set.
|
||||
void AddField(const UnknownField& field);
|
||||
|
||||
// Parsing helpers -------------------------------------------------
|
||||
// These work exactly like the similarly-named methods of Message.
|
||||
|
||||
bool MergeFromCodedStream(io::CodedInputStream* input);
|
||||
bool ParseFromCodedStream(io::CodedInputStream* input);
|
||||
bool ParseFromZeroCopyStream(io::ZeroCopyInputStream* input);
|
||||
bool ParseFromArray(const void* data, int size);
|
||||
inline bool ParseFromString(const string& data) {
|
||||
return ParseFromArray(data.data(), data.size());
|
||||
}
|
||||
|
||||
private:
|
||||
void ClearFallback();
|
||||
|
||||
vector<UnknownField>* fields_;
|
||||
|
||||
GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(UnknownFieldSet);
|
||||
};
|
||||
|
||||
// Represents one field in an UnknownFieldSet.
|
||||
class LIBPROTOBUF_EXPORT UnknownField {
|
||||
public:
|
||||
enum Type {
|
||||
TYPE_VARINT,
|
||||
TYPE_FIXED32,
|
||||
TYPE_FIXED64,
|
||||
TYPE_LENGTH_DELIMITED,
|
||||
TYPE_GROUP
|
||||
};
|
||||
|
||||
// The field's tag number, as seen on the wire.
|
||||
inline int number() const;
|
||||
|
||||
// The field type.
|
||||
inline Type type() const;
|
||||
|
||||
// Accessors -------------------------------------------------------
|
||||
// Each method works only for UnknownFields of the corresponding type.
|
||||
|
||||
inline uint64 varint() const;
|
||||
inline uint32 fixed32() const;
|
||||
inline uint64 fixed64() const;
|
||||
inline const string& length_delimited() const;
|
||||
inline const UnknownFieldSet& group() const;
|
||||
|
||||
inline void set_varint(uint64 value);
|
||||
inline void set_fixed32(uint32 value);
|
||||
inline void set_fixed64(uint64 value);
|
||||
inline void set_length_delimited(const string& value);
|
||||
inline string* mutable_length_delimited();
|
||||
inline UnknownFieldSet* mutable_group();
|
||||
|
||||
private:
|
||||
friend class UnknownFieldSet;
|
||||
|
||||
// If this UnknownField contains a pointer, delete it.
|
||||
void Delete();
|
||||
|
||||
// Make a deep copy of any pointers in this UnknownField.
|
||||
void DeepCopy();
|
||||
|
||||
unsigned int number_ : 29;
|
||||
unsigned int type_ : 3;
|
||||
union {
|
||||
uint64 varint_;
|
||||
uint32 fixed32_;
|
||||
uint64 fixed64_;
|
||||
string* length_delimited_;
|
||||
UnknownFieldSet* group_;
|
||||
};
|
||||
};
|
||||
|
||||
// ===================================================================
|
||||
// inline implementations
|
||||
|
||||
inline void UnknownFieldSet::Clear() {
|
||||
if (fields_ != NULL) {
|
||||
ClearFallback();
|
||||
}
|
||||
}
|
||||
|
||||
inline bool UnknownFieldSet::empty() const {
|
||||
return fields_ == NULL || fields_->empty();
|
||||
}
|
||||
|
||||
inline void UnknownFieldSet::Swap(UnknownFieldSet* x) {
|
||||
std::swap(fields_, x->fields_);
|
||||
}
|
||||
|
||||
inline int UnknownFieldSet::field_count() const {
|
||||
return (fields_ == NULL) ? 0 : fields_->size();
|
||||
}
|
||||
inline const UnknownField& UnknownFieldSet::field(int index) const {
|
||||
return (*fields_)[index];
|
||||
}
|
||||
inline UnknownField* UnknownFieldSet::mutable_field(int index) {
|
||||
return &(*fields_)[index];
|
||||
}
|
||||
|
||||
inline void UnknownFieldSet::AddLengthDelimited(
|
||||
int number, const string& value) {
|
||||
AddLengthDelimited(number)->assign(value);
|
||||
}
|
||||
|
||||
inline int UnknownField::number() const { return number_; }
|
||||
inline UnknownField::Type UnknownField::type() const {
|
||||
return static_cast<Type>(type_);
|
||||
}
|
||||
|
||||
inline uint64 UnknownField::varint () const {
|
||||
GOOGLE_DCHECK_EQ(type_, TYPE_VARINT);
|
||||
return varint_;
|
||||
}
|
||||
inline uint32 UnknownField::fixed32() const {
|
||||
GOOGLE_DCHECK_EQ(type_, TYPE_FIXED32);
|
||||
return fixed32_;
|
||||
}
|
||||
inline uint64 UnknownField::fixed64() const {
|
||||
GOOGLE_DCHECK_EQ(type_, TYPE_FIXED64);
|
||||
return fixed64_;
|
||||
}
|
||||
inline const string& UnknownField::length_delimited() const {
|
||||
GOOGLE_DCHECK_EQ(type_, TYPE_LENGTH_DELIMITED);
|
||||
return *length_delimited_;
|
||||
}
|
||||
inline const UnknownFieldSet& UnknownField::group() const {
|
||||
GOOGLE_DCHECK_EQ(type_, TYPE_GROUP);
|
||||
return *group_;
|
||||
}
|
||||
|
||||
inline void UnknownField::set_varint(uint64 value) {
|
||||
GOOGLE_DCHECK_EQ(type_, TYPE_VARINT);
|
||||
varint_ = value;
|
||||
}
|
||||
inline void UnknownField::set_fixed32(uint32 value) {
|
||||
GOOGLE_DCHECK_EQ(type_, TYPE_FIXED32);
|
||||
fixed32_ = value;
|
||||
}
|
||||
inline void UnknownField::set_fixed64(uint64 value) {
|
||||
GOOGLE_DCHECK_EQ(type_, TYPE_FIXED64);
|
||||
fixed64_ = value;
|
||||
}
|
||||
inline void UnknownField::set_length_delimited(const string& value) {
|
||||
GOOGLE_DCHECK_EQ(type_, TYPE_LENGTH_DELIMITED);
|
||||
length_delimited_->assign(value);
|
||||
}
|
||||
inline string* UnknownField::mutable_length_delimited() {
|
||||
GOOGLE_DCHECK_EQ(type_, TYPE_LENGTH_DELIMITED);
|
||||
return length_delimited_;
|
||||
}
|
||||
inline UnknownFieldSet* UnknownField::mutable_group() {
|
||||
GOOGLE_DCHECK_EQ(type_, TYPE_GROUP);
|
||||
return group_;
|
||||
}
|
||||
|
||||
} // namespace protobuf
|
||||
|
||||
} // namespace google
|
||||
#endif // GOOGLE_PROTOBUF_UNKNOWN_FIELD_SET_H__
|
||||
File diff suppressed because it is too large
Load Diff
@ -1,304 +0,0 @@
|
||||
// Protocol Buffers - Google's data interchange format
|
||||
// Copyright 2008 Google Inc. All rights reserved.
|
||||
// http://code.google.com/p/protobuf/
|
||||
//
|
||||
// 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.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// 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.
|
||||
|
||||
// Author: kenton@google.com (Kenton Varda)
|
||||
// atenasio@google.com (Chris Atenasio) (ZigZag transform)
|
||||
// Based on original Protocol Buffers design by
|
||||
// Sanjay Ghemawat, Jeff Dean, and others.
|
||||
//
|
||||
// This header is logically internal, but is made public because it is used
|
||||
// from protocol-compiler-generated code, which may reside in other components.
|
||||
|
||||
#ifndef GOOGLE_PROTOBUF_WIRE_FORMAT_H__
|
||||
#define GOOGLE_PROTOBUF_WIRE_FORMAT_H__
|
||||
|
||||
#include <string>
|
||||
#include <google/protobuf/descriptor.pb.h>
|
||||
#include <google/protobuf/descriptor.h>
|
||||
#include <google/protobuf/message.h>
|
||||
#include <google/protobuf/wire_format_lite.h>
|
||||
|
||||
// Do UTF-8 validation on string type in Debug build only
|
||||
#ifndef NDEBUG
|
||||
#define GOOGLE_PROTOBUF_UTF8_VALIDATION_ENABLED
|
||||
#endif
|
||||
|
||||
namespace google {
|
||||
namespace protobuf {
|
||||
namespace io {
|
||||
class CodedInputStream; // coded_stream.h
|
||||
class CodedOutputStream; // coded_stream.h
|
||||
}
|
||||
class UnknownFieldSet; // unknown_field_set.h
|
||||
}
|
||||
|
||||
namespace protobuf {
|
||||
namespace internal {
|
||||
|
||||
// This class is for internal use by the protocol buffer library and by
|
||||
// protocol-complier-generated message classes. It must not be called
|
||||
// directly by clients.
|
||||
//
|
||||
// This class contains code for implementing the binary protocol buffer
|
||||
// wire format via reflection. The WireFormatLite class implements the
|
||||
// non-reflection based routines.
|
||||
//
|
||||
// This class is really a namespace that contains only static methods
|
||||
class LIBPROTOBUF_EXPORT WireFormat {
|
||||
public:
|
||||
|
||||
// Given a field return its WireType
|
||||
static inline WireFormatLite::WireType WireTypeForField(
|
||||
const FieldDescriptor* field);
|
||||
|
||||
// Given a FieldSescriptor::Type return its WireType
|
||||
static inline WireFormatLite::WireType WireTypeForFieldType(
|
||||
FieldDescriptor::Type type);
|
||||
|
||||
// Compute the byte size of a tag. For groups, this includes both the start
|
||||
// and end tags.
|
||||
static inline int TagSize(int field_number, FieldDescriptor::Type type);
|
||||
|
||||
// These procedures can be used to implement the methods of Message which
|
||||
// handle parsing and serialization of the protocol buffer wire format
|
||||
// using only the Reflection interface. When you ask the protocol
|
||||
// compiler to optimize for code size rather than speed, it will implement
|
||||
// those methods in terms of these procedures. Of course, these are much
|
||||
// slower than the specialized implementations which the protocol compiler
|
||||
// generates when told to optimize for speed.
|
||||
|
||||
// Read a message in protocol buffer wire format.
|
||||
//
|
||||
// This procedure reads either to the end of the input stream or through
|
||||
// a WIRETYPE_END_GROUP tag ending the message, whichever comes first.
|
||||
// It returns false if the input is invalid.
|
||||
//
|
||||
// Required fields are NOT checked by this method. You must call
|
||||
// IsInitialized() on the resulting message yourself.
|
||||
static bool ParseAndMergePartial(io::CodedInputStream* input,
|
||||
Message* message);
|
||||
|
||||
// Serialize a message in protocol buffer wire format.
|
||||
//
|
||||
// Any embedded messages within the message must have their correct sizes
|
||||
// cached. However, the top-level message need not; its size is passed as
|
||||
// a parameter to this procedure.
|
||||
//
|
||||
// These return false iff the underlying stream returns a write error.
|
||||
static void SerializeWithCachedSizes(
|
||||
const Message& message,
|
||||
int size, io::CodedOutputStream* output);
|
||||
|
||||
// Implements Message::ByteSize() via reflection. WARNING: The result
|
||||
// of this method is *not* cached anywhere. However, all embedded messages
|
||||
// will have their ByteSize() methods called, so their sizes will be cached.
|
||||
// Therefore, calling this method is sufficient to allow you to call
|
||||
// WireFormat::SerializeWithCachedSizes() on the same object.
|
||||
static int ByteSize(const Message& message);
|
||||
|
||||
// -----------------------------------------------------------------
|
||||
// Helpers for dealing with unknown fields
|
||||
|
||||
// Skips a field value of the given WireType. The input should start
|
||||
// positioned immediately after the tag. If unknown_fields is non-NULL,
|
||||
// the contents of the field will be added to it.
|
||||
static bool SkipField(io::CodedInputStream* input, uint32 tag,
|
||||
UnknownFieldSet* unknown_fields);
|
||||
|
||||
// Reads and ignores a message from the input. If unknown_fields is non-NULL,
|
||||
// the contents will be added to it.
|
||||
static bool SkipMessage(io::CodedInputStream* input,
|
||||
UnknownFieldSet* unknown_fields);
|
||||
|
||||
// Write the contents of an UnknownFieldSet to the output.
|
||||
static void SerializeUnknownFields(const UnknownFieldSet& unknown_fields,
|
||||
io::CodedOutputStream* output);
|
||||
// Same as above, except writing directly to the provided buffer.
|
||||
// Requires that the buffer have sufficient capacity for
|
||||
// ComputeUnknownFieldsSize(unknown_fields).
|
||||
//
|
||||
// Returns a pointer past the last written byte.
|
||||
static uint8* SerializeUnknownFieldsToArray(
|
||||
const UnknownFieldSet& unknown_fields,
|
||||
uint8* target);
|
||||
|
||||
// Same thing except for messages that have the message_set_wire_format
|
||||
// option.
|
||||
static void SerializeUnknownMessageSetItems(
|
||||
const UnknownFieldSet& unknown_fields,
|
||||
io::CodedOutputStream* output);
|
||||
// Same as above, except writing directly to the provided buffer.
|
||||
// Requires that the buffer have sufficient capacity for
|
||||
// ComputeUnknownMessageSetItemsSize(unknown_fields).
|
||||
//
|
||||
// Returns a pointer past the last written byte.
|
||||
static uint8* SerializeUnknownMessageSetItemsToArray(
|
||||
const UnknownFieldSet& unknown_fields,
|
||||
uint8* target);
|
||||
|
||||
// Compute the size of the UnknownFieldSet on the wire.
|
||||
static int ComputeUnknownFieldsSize(const UnknownFieldSet& unknown_fields);
|
||||
|
||||
// Same thing except for messages that have the message_set_wire_format
|
||||
// option.
|
||||
static int ComputeUnknownMessageSetItemsSize(
|
||||
const UnknownFieldSet& unknown_fields);
|
||||
|
||||
|
||||
// Helper functions for encoding and decoding tags. (Inlined below and in
|
||||
// _inl.h)
|
||||
//
|
||||
// This is different from MakeTag(field->number(), field->type()) in the case
|
||||
// of packed repeated fields.
|
||||
static uint32 MakeTag(const FieldDescriptor* field);
|
||||
|
||||
// Parse a single field. The input should start out positioned immidately
|
||||
// after the tag.
|
||||
static bool ParseAndMergeField(
|
||||
uint32 tag,
|
||||
const FieldDescriptor* field, // May be NULL for unknown
|
||||
Message* message,
|
||||
io::CodedInputStream* input);
|
||||
|
||||
// Serialize a single field.
|
||||
static void SerializeFieldWithCachedSizes(
|
||||
const FieldDescriptor* field, // Cannot be NULL
|
||||
const Message& message,
|
||||
io::CodedOutputStream* output);
|
||||
|
||||
// Compute size of a single field. If the field is a message type, this
|
||||
// will call ByteSize() for the embedded message, insuring that it caches
|
||||
// its size.
|
||||
static int FieldByteSize(
|
||||
const FieldDescriptor* field, // Cannot be NULL
|
||||
const Message& message);
|
||||
|
||||
// Parse/serialize a MessageSet::Item group. Used with messages that use
|
||||
// opion message_set_wire_format = true.
|
||||
static bool ParseAndMergeMessageSetItem(
|
||||
io::CodedInputStream* input,
|
||||
Message* message);
|
||||
static void SerializeMessageSetItemWithCachedSizes(
|
||||
const FieldDescriptor* field,
|
||||
const Message& message,
|
||||
io::CodedOutputStream* output);
|
||||
static int MessageSetItemByteSize(
|
||||
const FieldDescriptor* field,
|
||||
const Message& message);
|
||||
|
||||
// Computes the byte size of a field, excluding tags. For packed fields, it
|
||||
// only includes the size of the raw data, and not the size of the total
|
||||
// length, but for other length-delimited types, the size of the length is
|
||||
// included.
|
||||
static int FieldDataOnlyByteSize(
|
||||
const FieldDescriptor* field, // Cannot be NULL
|
||||
const Message& message);
|
||||
|
||||
enum Operation {
|
||||
PARSE,
|
||||
SERIALIZE,
|
||||
};
|
||||
|
||||
// Verifies that a string field is valid UTF8, logging an error if not.
|
||||
static void VerifyUTF8String(const char* data, int size, Operation op);
|
||||
|
||||
private:
|
||||
// Verifies that a string field is valid UTF8, logging an error if not.
|
||||
static void VerifyUTF8StringFallback(
|
||||
const char* data,
|
||||
int size,
|
||||
Operation op);
|
||||
|
||||
|
||||
|
||||
GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(WireFormat);
|
||||
};
|
||||
|
||||
// Subclass of FieldSkipper which saves skipped fields to an UnknownFieldSet.
|
||||
class LIBPROTOBUF_EXPORT UnknownFieldSetFieldSkipper : public FieldSkipper {
|
||||
public:
|
||||
UnknownFieldSetFieldSkipper(UnknownFieldSet* unknown_fields)
|
||||
: unknown_fields_(unknown_fields) {}
|
||||
virtual ~UnknownFieldSetFieldSkipper() {}
|
||||
|
||||
// implements FieldSkipper -----------------------------------------
|
||||
virtual bool SkipField(io::CodedInputStream* input, uint32 tag);
|
||||
virtual bool SkipMessage(io::CodedInputStream* input);
|
||||
virtual void SkipUnknownEnum(int field_number, int value);
|
||||
|
||||
private:
|
||||
UnknownFieldSet* unknown_fields_;
|
||||
};
|
||||
|
||||
// inline methods ====================================================
|
||||
|
||||
inline WireFormatLite::WireType WireFormat::WireTypeForField(
|
||||
const FieldDescriptor* field) {
|
||||
if (field->options().packed()) {
|
||||
return WireFormatLite::WIRETYPE_LENGTH_DELIMITED;
|
||||
} else {
|
||||
return WireTypeForFieldType(field->type());
|
||||
}
|
||||
}
|
||||
|
||||
inline WireFormatLite::WireType WireFormat::WireTypeForFieldType(
|
||||
FieldDescriptor::Type type) {
|
||||
// Some compilers don't like enum -> enum casts, so we implicit_cast to
|
||||
// int first.
|
||||
return WireFormatLite::WireTypeForFieldType(
|
||||
static_cast<WireFormatLite::FieldType>(
|
||||
implicit_cast<int>(type)));
|
||||
}
|
||||
|
||||
inline uint32 WireFormat::MakeTag(const FieldDescriptor* field) {
|
||||
return WireFormatLite::MakeTag(field->number(), WireTypeForField(field));
|
||||
}
|
||||
|
||||
inline int WireFormat::TagSize(int field_number, FieldDescriptor::Type type) {
|
||||
// Some compilers don't like enum -> enum casts, so we implicit_cast to
|
||||
// int first.
|
||||
return WireFormatLite::TagSize(field_number,
|
||||
static_cast<WireFormatLite::FieldType>(
|
||||
implicit_cast<int>(type)));
|
||||
}
|
||||
|
||||
inline void WireFormat::VerifyUTF8String(const char* data, int size,
|
||||
WireFormat::Operation op) {
|
||||
#ifdef GOOGLE_PROTOBUF_UTF8_VALIDATION_ENABLED
|
||||
WireFormat::VerifyUTF8StringFallback(data, size, op);
|
||||
#endif
|
||||
}
|
||||
|
||||
|
||||
} // namespace internal
|
||||
} // namespace protobuf
|
||||
|
||||
} // namespace google
|
||||
#endif // GOOGLE_PROTOBUF_WIRE_FORMAT_H__
|
||||
@ -1,359 +0,0 @@
|
||||
// Protocol Buffers - Google's data interchange format
|
||||
// Copyright 2008 Google Inc. All rights reserved.
|
||||
// http://code.google.com/p/protobuf/
|
||||
//
|
||||
// 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.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// 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.
|
||||
|
||||
// Author: kenton@google.com (Kenton Varda)
|
||||
// Based on original Protocol Buffers design by
|
||||
// Sanjay Ghemawat, Jeff Dean, and others.
|
||||
|
||||
#include <google/protobuf/wire_format_lite_inl.h>
|
||||
|
||||
#include <stack>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
#include <google/protobuf/stubs/common.h>
|
||||
#include <google/protobuf/io/coded_stream_inl.h>
|
||||
#include <google/protobuf/io/zero_copy_stream.h>
|
||||
#include <google/protobuf/io/zero_copy_stream_impl.h>
|
||||
|
||||
namespace google {
|
||||
namespace protobuf {
|
||||
namespace internal {
|
||||
|
||||
#ifndef _MSC_VER // MSVC doesn't like definitions of inline constants, GCC
|
||||
// requires them.
|
||||
const int WireFormatLite::kMessageSetItemStartTag;
|
||||
const int WireFormatLite::kMessageSetItemEndTag;
|
||||
const int WireFormatLite::kMessageSetTypeIdTag;
|
||||
const int WireFormatLite::kMessageSetMessageTag;
|
||||
|
||||
#endif
|
||||
|
||||
const int WireFormatLite::kMessageSetItemTagsSize =
|
||||
io::CodedOutputStream::VarintSize32(kMessageSetItemStartTag) +
|
||||
io::CodedOutputStream::VarintSize32(kMessageSetItemEndTag) +
|
||||
io::CodedOutputStream::VarintSize32(kMessageSetTypeIdTag) +
|
||||
io::CodedOutputStream::VarintSize32(kMessageSetMessageTag);
|
||||
|
||||
const WireFormatLite::CppType
|
||||
WireFormatLite::kFieldTypeToCppTypeMap[MAX_FIELD_TYPE + 1] = {
|
||||
static_cast<CppType>(0), // 0 is reserved for errors
|
||||
|
||||
CPPTYPE_DOUBLE, // TYPE_DOUBLE
|
||||
CPPTYPE_FLOAT, // TYPE_FLOAT
|
||||
CPPTYPE_INT64, // TYPE_INT64
|
||||
CPPTYPE_UINT64, // TYPE_UINT64
|
||||
CPPTYPE_INT32, // TYPE_INT32
|
||||
CPPTYPE_UINT64, // TYPE_FIXED64
|
||||
CPPTYPE_UINT32, // TYPE_FIXED32
|
||||
CPPTYPE_BOOL, // TYPE_BOOL
|
||||
CPPTYPE_STRING, // TYPE_STRING
|
||||
CPPTYPE_MESSAGE, // TYPE_GROUP
|
||||
CPPTYPE_MESSAGE, // TYPE_MESSAGE
|
||||
CPPTYPE_STRING, // TYPE_BYTES
|
||||
CPPTYPE_UINT32, // TYPE_UINT32
|
||||
CPPTYPE_ENUM, // TYPE_ENUM
|
||||
CPPTYPE_INT32, // TYPE_SFIXED32
|
||||
CPPTYPE_INT64, // TYPE_SFIXED64
|
||||
CPPTYPE_INT32, // TYPE_SINT32
|
||||
CPPTYPE_INT64, // TYPE_SINT64
|
||||
};
|
||||
|
||||
const WireFormatLite::WireType
|
||||
WireFormatLite::kWireTypeForFieldType[MAX_FIELD_TYPE + 1] = {
|
||||
static_cast<WireFormatLite::WireType>(-1), // invalid
|
||||
WireFormatLite::WIRETYPE_FIXED64, // TYPE_DOUBLE
|
||||
WireFormatLite::WIRETYPE_FIXED32, // TYPE_FLOAT
|
||||
WireFormatLite::WIRETYPE_VARINT, // TYPE_INT64
|
||||
WireFormatLite::WIRETYPE_VARINT, // TYPE_UINT64
|
||||
WireFormatLite::WIRETYPE_VARINT, // TYPE_INT32
|
||||
WireFormatLite::WIRETYPE_FIXED64, // TYPE_FIXED64
|
||||
WireFormatLite::WIRETYPE_FIXED32, // TYPE_FIXED32
|
||||
WireFormatLite::WIRETYPE_VARINT, // TYPE_BOOL
|
||||
WireFormatLite::WIRETYPE_LENGTH_DELIMITED, // TYPE_STRING
|
||||
WireFormatLite::WIRETYPE_START_GROUP, // TYPE_GROUP
|
||||
WireFormatLite::WIRETYPE_LENGTH_DELIMITED, // TYPE_MESSAGE
|
||||
WireFormatLite::WIRETYPE_LENGTH_DELIMITED, // TYPE_BYTES
|
||||
WireFormatLite::WIRETYPE_VARINT, // TYPE_UINT32
|
||||
WireFormatLite::WIRETYPE_VARINT, // TYPE_ENUM
|
||||
WireFormatLite::WIRETYPE_FIXED32, // TYPE_SFIXED32
|
||||
WireFormatLite::WIRETYPE_FIXED64, // TYPE_SFIXED64
|
||||
WireFormatLite::WIRETYPE_VARINT, // TYPE_SINT32
|
||||
WireFormatLite::WIRETYPE_VARINT, // TYPE_SINT64
|
||||
};
|
||||
|
||||
bool WireFormatLite::SkipField(
|
||||
io::CodedInputStream* input, uint32 tag) {
|
||||
switch (WireFormatLite::GetTagWireType(tag)) {
|
||||
case WireFormatLite::WIRETYPE_VARINT: {
|
||||
uint64 value;
|
||||
if (!input->ReadVarint64(&value)) return false;
|
||||
return true;
|
||||
}
|
||||
case WireFormatLite::WIRETYPE_FIXED64: {
|
||||
uint64 value;
|
||||
if (!input->ReadLittleEndian64(&value)) return false;
|
||||
return true;
|
||||
}
|
||||
case WireFormatLite::WIRETYPE_LENGTH_DELIMITED: {
|
||||
uint32 length;
|
||||
if (!input->ReadVarint32(&length)) return false;
|
||||
if (!input->Skip(length)) return false;
|
||||
return true;
|
||||
}
|
||||
case WireFormatLite::WIRETYPE_START_GROUP: {
|
||||
if (!input->IncrementRecursionDepth()) return false;
|
||||
if (!SkipMessage(input)) return false;
|
||||
input->DecrementRecursionDepth();
|
||||
// Check that the ending tag matched the starting tag.
|
||||
if (!input->LastTagWas(WireFormatLite::MakeTag(
|
||||
WireFormatLite::GetTagFieldNumber(tag),
|
||||
WireFormatLite::WIRETYPE_END_GROUP))) {
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
case WireFormatLite::WIRETYPE_END_GROUP: {
|
||||
return false;
|
||||
}
|
||||
case WireFormatLite::WIRETYPE_FIXED32: {
|
||||
uint32 value;
|
||||
if (!input->ReadLittleEndian32(&value)) return false;
|
||||
return true;
|
||||
}
|
||||
default: {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
bool WireFormatLite::SkipMessage(io::CodedInputStream* input) {
|
||||
while(true) {
|
||||
uint32 tag = input->ReadTag();
|
||||
if (tag == 0) {
|
||||
// End of input. This is a valid place to end, so return true.
|
||||
return true;
|
||||
}
|
||||
|
||||
WireFormatLite::WireType wire_type = WireFormatLite::GetTagWireType(tag);
|
||||
|
||||
if (wire_type == WireFormatLite::WIRETYPE_END_GROUP) {
|
||||
// Must be the end of the message.
|
||||
return true;
|
||||
}
|
||||
|
||||
if (!SkipField(input, tag)) return false;
|
||||
}
|
||||
}
|
||||
|
||||
bool FieldSkipper::SkipField(
|
||||
io::CodedInputStream* input, uint32 tag) {
|
||||
return WireFormatLite::SkipField(input, tag);
|
||||
}
|
||||
|
||||
bool FieldSkipper::SkipMessage(io::CodedInputStream* input) {
|
||||
return WireFormatLite::SkipMessage(input);
|
||||
}
|
||||
|
||||
void FieldSkipper::SkipUnknownEnum(
|
||||
int field_number, int value) {
|
||||
// Nothing.
|
||||
}
|
||||
|
||||
bool WireFormatLite::ReadPackedEnumNoInline(io::CodedInputStream* input,
|
||||
bool (*is_valid)(int),
|
||||
RepeatedField<int>* values) {
|
||||
uint32 length;
|
||||
if (!input->ReadVarint32(&length)) return false;
|
||||
io::CodedInputStream::Limit limit = input->PushLimit(length);
|
||||
while (input->BytesUntilLimit() > 0) {
|
||||
int value;
|
||||
if (!google::protobuf::internal::WireFormatLite::ReadPrimitive<
|
||||
int, WireFormatLite::TYPE_ENUM>(input, &value)) {
|
||||
return false;
|
||||
}
|
||||
if (is_valid(value)) {
|
||||
values->Add(value);
|
||||
}
|
||||
}
|
||||
input->PopLimit(limit);
|
||||
return true;
|
||||
}
|
||||
|
||||
void WireFormatLite::WriteInt32(int field_number, int32 value,
|
||||
io::CodedOutputStream* output) {
|
||||
WriteTag(field_number, WIRETYPE_VARINT, output);
|
||||
WriteInt32NoTag(value, output);
|
||||
}
|
||||
void WireFormatLite::WriteInt64(int field_number, int64 value,
|
||||
io::CodedOutputStream* output) {
|
||||
WriteTag(field_number, WIRETYPE_VARINT, output);
|
||||
WriteInt64NoTag(value, output);
|
||||
}
|
||||
void WireFormatLite::WriteUInt32(int field_number, uint32 value,
|
||||
io::CodedOutputStream* output) {
|
||||
WriteTag(field_number, WIRETYPE_VARINT, output);
|
||||
WriteUInt32NoTag(value, output);
|
||||
}
|
||||
void WireFormatLite::WriteUInt64(int field_number, uint64 value,
|
||||
io::CodedOutputStream* output) {
|
||||
WriteTag(field_number, WIRETYPE_VARINT, output);
|
||||
WriteUInt64NoTag(value, output);
|
||||
}
|
||||
void WireFormatLite::WriteSInt32(int field_number, int32 value,
|
||||
io::CodedOutputStream* output) {
|
||||
WriteTag(field_number, WIRETYPE_VARINT, output);
|
||||
WriteSInt32NoTag(value, output);
|
||||
}
|
||||
void WireFormatLite::WriteSInt64(int field_number, int64 value,
|
||||
io::CodedOutputStream* output) {
|
||||
WriteTag(field_number, WIRETYPE_VARINT, output);
|
||||
WriteSInt64NoTag(value, output);
|
||||
}
|
||||
void WireFormatLite::WriteFixed32(int field_number, uint32 value,
|
||||
io::CodedOutputStream* output) {
|
||||
WriteTag(field_number, WIRETYPE_FIXED32, output);
|
||||
WriteFixed32NoTag(value, output);
|
||||
}
|
||||
void WireFormatLite::WriteFixed64(int field_number, uint64 value,
|
||||
io::CodedOutputStream* output) {
|
||||
WriteTag(field_number, WIRETYPE_FIXED64, output);
|
||||
WriteFixed64NoTag(value, output);
|
||||
}
|
||||
void WireFormatLite::WriteSFixed32(int field_number, int32 value,
|
||||
io::CodedOutputStream* output) {
|
||||
WriteTag(field_number, WIRETYPE_FIXED32, output);
|
||||
WriteSFixed32NoTag(value, output);
|
||||
}
|
||||
void WireFormatLite::WriteSFixed64(int field_number, int64 value,
|
||||
io::CodedOutputStream* output) {
|
||||
WriteTag(field_number, WIRETYPE_FIXED64, output);
|
||||
WriteSFixed64NoTag(value, output);
|
||||
}
|
||||
void WireFormatLite::WriteFloat(int field_number, float value,
|
||||
io::CodedOutputStream* output) {
|
||||
WriteTag(field_number, WIRETYPE_FIXED32, output);
|
||||
WriteFloatNoTag(value, output);
|
||||
}
|
||||
void WireFormatLite::WriteDouble(int field_number, double value,
|
||||
io::CodedOutputStream* output) {
|
||||
WriteTag(field_number, WIRETYPE_FIXED64, output);
|
||||
WriteDoubleNoTag(value, output);
|
||||
}
|
||||
void WireFormatLite::WriteBool(int field_number, bool value,
|
||||
io::CodedOutputStream* output) {
|
||||
WriteTag(field_number, WIRETYPE_VARINT, output);
|
||||
WriteBoolNoTag(value, output);
|
||||
}
|
||||
void WireFormatLite::WriteEnum(int field_number, int value,
|
||||
io::CodedOutputStream* output) {
|
||||
WriteTag(field_number, WIRETYPE_VARINT, output);
|
||||
WriteEnumNoTag(value, output);
|
||||
}
|
||||
|
||||
void WireFormatLite::WriteString(int field_number, const string& value,
|
||||
io::CodedOutputStream* output) {
|
||||
// String is for UTF-8 text only
|
||||
WriteTag(field_number, WIRETYPE_LENGTH_DELIMITED, output);
|
||||
output->WriteVarint32(value.size());
|
||||
output->WriteString(value);
|
||||
}
|
||||
void WireFormatLite::WriteBytes(int field_number, const string& value,
|
||||
io::CodedOutputStream* output) {
|
||||
WriteTag(field_number, WIRETYPE_LENGTH_DELIMITED, output);
|
||||
output->WriteVarint32(value.size());
|
||||
output->WriteString(value);
|
||||
}
|
||||
|
||||
|
||||
void WireFormatLite::WriteGroup(int field_number,
|
||||
const MessageLite& value,
|
||||
io::CodedOutputStream* output) {
|
||||
WriteTag(field_number, WIRETYPE_START_GROUP, output);
|
||||
value.SerializeWithCachedSizes(output);
|
||||
WriteTag(field_number, WIRETYPE_END_GROUP, output);
|
||||
}
|
||||
|
||||
void WireFormatLite::WriteMessage(int field_number,
|
||||
const MessageLite& value,
|
||||
io::CodedOutputStream* output) {
|
||||
WriteTag(field_number, WIRETYPE_LENGTH_DELIMITED, output);
|
||||
const int size = value.GetCachedSize();
|
||||
output->WriteVarint32(size);
|
||||
value.SerializeWithCachedSizes(output);
|
||||
}
|
||||
|
||||
void WireFormatLite::WriteGroupMaybeToArray(int field_number,
|
||||
const MessageLite& value,
|
||||
io::CodedOutputStream* output) {
|
||||
WriteTag(field_number, WIRETYPE_START_GROUP, output);
|
||||
const int size = value.GetCachedSize();
|
||||
uint8* target = output->GetDirectBufferForNBytesAndAdvance(size);
|
||||
if (target != NULL) {
|
||||
uint8* end = value.SerializeWithCachedSizesToArray(target);
|
||||
GOOGLE_DCHECK_EQ(end - target, size);
|
||||
} else {
|
||||
value.SerializeWithCachedSizes(output);
|
||||
}
|
||||
WriteTag(field_number, WIRETYPE_END_GROUP, output);
|
||||
}
|
||||
|
||||
void WireFormatLite::WriteMessageMaybeToArray(int field_number,
|
||||
const MessageLite& value,
|
||||
io::CodedOutputStream* output) {
|
||||
WriteTag(field_number, WIRETYPE_LENGTH_DELIMITED, output);
|
||||
const int size = value.GetCachedSize();
|
||||
output->WriteVarint32(size);
|
||||
uint8* target = output->GetDirectBufferForNBytesAndAdvance(size);
|
||||
if (target != NULL) {
|
||||
uint8* end = value.SerializeWithCachedSizesToArray(target);
|
||||
GOOGLE_DCHECK_EQ(end - target, size);
|
||||
} else {
|
||||
value.SerializeWithCachedSizes(output);
|
||||
}
|
||||
}
|
||||
|
||||
bool WireFormatLite::ReadString(io::CodedInputStream* input,
|
||||
string* value) {
|
||||
// String is for UTF-8 text only
|
||||
uint32 length;
|
||||
if (!input->ReadVarint32(&length)) return false;
|
||||
if (!input->InternalReadStringInline(value, length)) return false;
|
||||
return true;
|
||||
}
|
||||
bool WireFormatLite::ReadBytes(io::CodedInputStream* input,
|
||||
string* value) {
|
||||
uint32 length;
|
||||
if (!input->ReadVarint32(&length)) return false;
|
||||
return input->InternalReadStringInline(value, length);
|
||||
}
|
||||
|
||||
} // namespace internal
|
||||
} // namespace protobuf
|
||||
} // namespace google
|
||||
@ -1,620 +0,0 @@
|
||||
// Protocol Buffers - Google's data interchange format
|
||||
// Copyright 2008 Google Inc. All rights reserved.
|
||||
// http://code.google.com/p/protobuf/
|
||||
//
|
||||
// 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.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// 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.
|
||||
|
||||
// Author: kenton@google.com (Kenton Varda)
|
||||
// atenasio@google.com (Chris Atenasio) (ZigZag transform)
|
||||
// wink@google.com (Wink Saville) (refactored from wire_format.h)
|
||||
// Based on original Protocol Buffers design by
|
||||
// Sanjay Ghemawat, Jeff Dean, and others.
|
||||
//
|
||||
// This header is logically internal, but is made public because it is used
|
||||
// from protocol-compiler-generated code, which may reside in other components.
|
||||
|
||||
#ifndef GOOGLE_PROTOBUF_WIRE_FORMAT_LITE_H__
|
||||
#define GOOGLE_PROTOBUF_WIRE_FORMAT_LITE_H__
|
||||
|
||||
#include <string>
|
||||
#include <google/protobuf/message_lite.h>
|
||||
|
||||
namespace google {
|
||||
|
||||
namespace protobuf {
|
||||
template <typename T> class RepeatedField; // repeated_field.h
|
||||
namespace io {
|
||||
class CodedInputStream; // coded_stream.h
|
||||
class CodedOutputStream; // coded_stream.h
|
||||
}
|
||||
}
|
||||
|
||||
namespace protobuf {
|
||||
namespace internal {
|
||||
|
||||
class StringPieceField;
|
||||
|
||||
// This class is for internal use by the protocol buffer library and by
|
||||
// protocol-complier-generated message classes. It must not be called
|
||||
// directly by clients.
|
||||
//
|
||||
// This class contains helpers for implementing the binary protocol buffer
|
||||
// wire format without the need for reflection. Use WireFormat when using
|
||||
// reflection.
|
||||
//
|
||||
// This class is really a namespace that contains only static methods.
|
||||
class LIBPROTOBUF_EXPORT WireFormatLite {
|
||||
public:
|
||||
|
||||
// -----------------------------------------------------------------
|
||||
// Helper constants and functions related to the format. These are
|
||||
// mostly meant for internal and generated code to use.
|
||||
|
||||
// The wire format is composed of a sequence of tag/value pairs, each
|
||||
// of which contains the value of one field (or one element of a repeated
|
||||
// field). Each tag is encoded as a varint. The lower bits of the tag
|
||||
// identify its wire type, which specifies the format of the data to follow.
|
||||
// The rest of the bits contain the field number. Each type of field (as
|
||||
// declared by FieldDescriptor::Type, in descriptor.h) maps to one of
|
||||
// these wire types. Immediately following each tag is the field's value,
|
||||
// encoded in the format specified by the wire type. Because the tag
|
||||
// identifies the encoding of this data, it is possible to skip
|
||||
// unrecognized fields for forwards compatibility.
|
||||
|
||||
enum WireType {
|
||||
WIRETYPE_VARINT = 0,
|
||||
WIRETYPE_FIXED64 = 1,
|
||||
WIRETYPE_LENGTH_DELIMITED = 2,
|
||||
WIRETYPE_START_GROUP = 3,
|
||||
WIRETYPE_END_GROUP = 4,
|
||||
WIRETYPE_FIXED32 = 5,
|
||||
};
|
||||
|
||||
// Lite alternative to FieldDescriptor::Type. Must be kept in sync.
|
||||
enum FieldType {
|
||||
TYPE_DOUBLE = 1,
|
||||
TYPE_FLOAT = 2,
|
||||
TYPE_INT64 = 3,
|
||||
TYPE_UINT64 = 4,
|
||||
TYPE_INT32 = 5,
|
||||
TYPE_FIXED64 = 6,
|
||||
TYPE_FIXED32 = 7,
|
||||
TYPE_BOOL = 8,
|
||||
TYPE_STRING = 9,
|
||||
TYPE_GROUP = 10,
|
||||
TYPE_MESSAGE = 11,
|
||||
TYPE_BYTES = 12,
|
||||
TYPE_UINT32 = 13,
|
||||
TYPE_ENUM = 14,
|
||||
TYPE_SFIXED32 = 15,
|
||||
TYPE_SFIXED64 = 16,
|
||||
TYPE_SINT32 = 17,
|
||||
TYPE_SINT64 = 18,
|
||||
MAX_FIELD_TYPE = 18,
|
||||
};
|
||||
|
||||
// Lite alternative to FieldDescriptor::CppType. Must be kept in sync.
|
||||
enum CppType {
|
||||
CPPTYPE_INT32 = 1,
|
||||
CPPTYPE_INT64 = 2,
|
||||
CPPTYPE_UINT32 = 3,
|
||||
CPPTYPE_UINT64 = 4,
|
||||
CPPTYPE_DOUBLE = 5,
|
||||
CPPTYPE_FLOAT = 6,
|
||||
CPPTYPE_BOOL = 7,
|
||||
CPPTYPE_ENUM = 8,
|
||||
CPPTYPE_STRING = 9,
|
||||
CPPTYPE_MESSAGE = 10,
|
||||
MAX_CPPTYPE = 10,
|
||||
};
|
||||
|
||||
// Helper method to get the CppType for a particular Type.
|
||||
static CppType FieldTypeToCppType(FieldType type);
|
||||
|
||||
// Given a FieldSescriptor::Type return its WireType
|
||||
static inline WireFormatLite::WireType WireTypeForFieldType(
|
||||
WireFormatLite::FieldType type) {
|
||||
return kWireTypeForFieldType[type];
|
||||
}
|
||||
|
||||
// Number of bits in a tag which identify the wire type.
|
||||
static const int kTagTypeBits = 3;
|
||||
// Mask for those bits.
|
||||
static const uint32 kTagTypeMask = (1 << kTagTypeBits) - 1;
|
||||
|
||||
// Helper functions for encoding and decoding tags. (Inlined below and in
|
||||
// _inl.h)
|
||||
//
|
||||
// This is different from MakeTag(field->number(), field->type()) in the case
|
||||
// of packed repeated fields.
|
||||
static uint32 MakeTag(int field_number, WireType type);
|
||||
static WireType GetTagWireType(uint32 tag);
|
||||
static int GetTagFieldNumber(uint32 tag);
|
||||
|
||||
// Compute the byte size of a tag. For groups, this includes both the start
|
||||
// and end tags.
|
||||
static inline int TagSize(int field_number, WireFormatLite::FieldType type);
|
||||
|
||||
// Skips a field value with the given tag. The input should start
|
||||
// positioned immediately after the tag. Skipped values are simply discarded,
|
||||
// not recorded anywhere. See WireFormat::SkipField() for a version that
|
||||
// records to an UnknownFieldSet.
|
||||
static bool SkipField(io::CodedInputStream* input, uint32 tag);
|
||||
|
||||
// Reads and ignores a message from the input. Skipped values are simply
|
||||
// discarded, not recorded anywhere. See WireFormat::SkipMessage() for a
|
||||
// version that records to an UnknownFieldSet.
|
||||
static bool SkipMessage(io::CodedInputStream* input);
|
||||
|
||||
// This macro does the same thing as WireFormatLite::MakeTag(), but the
|
||||
// result is usable as a compile-time constant, which makes it usable
|
||||
// as a switch case or a template input. WireFormatLite::MakeTag() is more
|
||||
// type-safe, though, so prefer it if possible.
|
||||
#define GOOGLE_PROTOBUF_WIRE_FORMAT_MAKE_TAG(FIELD_NUMBER, TYPE) \
|
||||
static_cast<uint32>( \
|
||||
((FIELD_NUMBER) << ::google::protobuf::internal::WireFormatLite::kTagTypeBits) \
|
||||
| (TYPE))
|
||||
|
||||
// These are the tags for the old MessageSet format, which was defined as:
|
||||
// message MessageSet {
|
||||
// repeated group Item = 1 {
|
||||
// required int32 type_id = 2;
|
||||
// required string message = 3;
|
||||
// }
|
||||
// }
|
||||
static const int kMessageSetItemNumber = 1;
|
||||
static const int kMessageSetTypeIdNumber = 2;
|
||||
static const int kMessageSetMessageNumber = 3;
|
||||
static const int kMessageSetItemStartTag =
|
||||
GOOGLE_PROTOBUF_WIRE_FORMAT_MAKE_TAG(kMessageSetItemNumber,
|
||||
WireFormatLite::WIRETYPE_START_GROUP);
|
||||
static const int kMessageSetItemEndTag =
|
||||
GOOGLE_PROTOBUF_WIRE_FORMAT_MAKE_TAG(kMessageSetItemNumber,
|
||||
WireFormatLite::WIRETYPE_END_GROUP);
|
||||
static const int kMessageSetTypeIdTag =
|
||||
GOOGLE_PROTOBUF_WIRE_FORMAT_MAKE_TAG(kMessageSetTypeIdNumber,
|
||||
WireFormatLite::WIRETYPE_VARINT);
|
||||
static const int kMessageSetMessageTag =
|
||||
GOOGLE_PROTOBUF_WIRE_FORMAT_MAKE_TAG(kMessageSetMessageNumber,
|
||||
WireFormatLite::WIRETYPE_LENGTH_DELIMITED);
|
||||
|
||||
// Byte size of all tags of a MessageSet::Item combined.
|
||||
static const int kMessageSetItemTagsSize;
|
||||
|
||||
// Helper functions for converting between floats/doubles and IEEE-754
|
||||
// uint32s/uint64s so that they can be written. (Assumes your platform
|
||||
// uses IEEE-754 floats.)
|
||||
static uint32 EncodeFloat(float value);
|
||||
static float DecodeFloat(uint32 value);
|
||||
static uint64 EncodeDouble(double value);
|
||||
static double DecodeDouble(uint64 value);
|
||||
|
||||
// Helper functions for mapping signed integers to unsigned integers in
|
||||
// such a way that numbers with small magnitudes will encode to smaller
|
||||
// varints. If you simply static_cast a negative number to an unsigned
|
||||
// number and varint-encode it, it will always take 10 bytes, defeating
|
||||
// the purpose of varint. So, for the "sint32" and "sint64" field types,
|
||||
// we ZigZag-encode the values.
|
||||
static uint32 ZigZagEncode32(int32 n);
|
||||
static int32 ZigZagDecode32(uint32 n);
|
||||
static uint64 ZigZagEncode64(int64 n);
|
||||
static int64 ZigZagDecode64(uint64 n);
|
||||
|
||||
// =================================================================
|
||||
// Methods for reading/writing individual field. The implementations
|
||||
// of these methods are defined in wire_format_lite_inl.h; you must #include
|
||||
// that file to use these.
|
||||
|
||||
// Avoid ugly line wrapping
|
||||
#define input io::CodedInputStream* input
|
||||
#define output io::CodedOutputStream* output
|
||||
#define field_number int field_number
|
||||
#define INL GOOGLE_ATTRIBUTE_ALWAYS_INLINE
|
||||
|
||||
// Read fields, not including tags. The assumption is that you already
|
||||
// read the tag to determine what field to read.
|
||||
|
||||
// For primitive fields, we just use a templatized routine parameterized by
|
||||
// the represented type and the FieldType. These are specialized with the
|
||||
// appropriate definition for each declared type.
|
||||
template <typename CType, enum FieldType DeclaredType>
|
||||
static inline bool ReadPrimitive(input, CType* value) INL;
|
||||
|
||||
// Reads repeated primitive values, with optimizations for repeats.
|
||||
// tag_size and tag should both be compile-time constants provided by the
|
||||
// protocol compiler.
|
||||
template <typename CType, enum FieldType DeclaredType>
|
||||
static inline bool ReadRepeatedPrimitive(int tag_size,
|
||||
uint32 tag,
|
||||
input,
|
||||
RepeatedField<CType>* value) INL;
|
||||
|
||||
// Identical to ReadRepeatedPrimitive, except will not inline the
|
||||
// implementation.
|
||||
template <typename CType, enum FieldType DeclaredType>
|
||||
static bool ReadRepeatedPrimitiveNoInline(int tag_size,
|
||||
uint32 tag,
|
||||
input,
|
||||
RepeatedField<CType>* value);
|
||||
|
||||
// Reads a primitive value directly from the provided buffer. It returns a
|
||||
// pointer past the segment of data that was read.
|
||||
//
|
||||
// This is only implemented for the types with fixed wire size, e.g.
|
||||
// float, double, and the (s)fixed* types.
|
||||
template <typename CType, enum FieldType DeclaredType>
|
||||
static inline const uint8* ReadPrimitiveFromArray(const uint8* buffer,
|
||||
CType* value) INL;
|
||||
|
||||
// Reads a primitive packed field.
|
||||
//
|
||||
// This is only implemented for packable types.
|
||||
template <typename CType, enum FieldType DeclaredType>
|
||||
static inline bool ReadPackedPrimitive(input,
|
||||
RepeatedField<CType>* value) INL;
|
||||
|
||||
// Identical to ReadPackedPrimitive, except will not inline the
|
||||
// implementation.
|
||||
template <typename CType, enum FieldType DeclaredType>
|
||||
static bool ReadPackedPrimitiveNoInline(input, RepeatedField<CType>* value);
|
||||
|
||||
// Read a packed enum field. Values for which is_valid() returns false are
|
||||
// dropped.
|
||||
static bool ReadPackedEnumNoInline(input,
|
||||
bool (*is_valid)(int),
|
||||
RepeatedField<int>* value);
|
||||
|
||||
static bool ReadString(input, string* value);
|
||||
static bool ReadBytes (input, string* value);
|
||||
|
||||
static inline bool ReadGroup (field_number, input, MessageLite* value);
|
||||
static inline bool ReadMessage(input, MessageLite* value);
|
||||
|
||||
// Like above, but de-virtualize the call to MergePartialFromCodedStream().
|
||||
// The pointer must point at an instance of MessageType, *not* a subclass (or
|
||||
// the subclass must not override MergePartialFromCodedStream()).
|
||||
template<typename MessageType>
|
||||
static inline bool ReadGroupNoVirtual(field_number, input,
|
||||
MessageType* value);
|
||||
template<typename MessageType>
|
||||
static inline bool ReadMessageNoVirtual(input, MessageType* value);
|
||||
|
||||
// Write a tag. The Write*() functions typically include the tag, so
|
||||
// normally there's no need to call this unless using the Write*NoTag()
|
||||
// variants.
|
||||
static inline void WriteTag(field_number, WireType type, output) INL;
|
||||
|
||||
// Write fields, without tags.
|
||||
static inline void WriteInt32NoTag (int32 value, output) INL;
|
||||
static inline void WriteInt64NoTag (int64 value, output) INL;
|
||||
static inline void WriteUInt32NoTag (uint32 value, output) INL;
|
||||
static inline void WriteUInt64NoTag (uint64 value, output) INL;
|
||||
static inline void WriteSInt32NoTag (int32 value, output) INL;
|
||||
static inline void WriteSInt64NoTag (int64 value, output) INL;
|
||||
static inline void WriteFixed32NoTag (uint32 value, output) INL;
|
||||
static inline void WriteFixed64NoTag (uint64 value, output) INL;
|
||||
static inline void WriteSFixed32NoTag(int32 value, output) INL;
|
||||
static inline void WriteSFixed64NoTag(int64 value, output) INL;
|
||||
static inline void WriteFloatNoTag (float value, output) INL;
|
||||
static inline void WriteDoubleNoTag (double value, output) INL;
|
||||
static inline void WriteBoolNoTag (bool value, output) INL;
|
||||
static inline void WriteEnumNoTag (int value, output) INL;
|
||||
|
||||
// Write fields, including tags.
|
||||
static void WriteInt32 (field_number, int32 value, output);
|
||||
static void WriteInt64 (field_number, int64 value, output);
|
||||
static void WriteUInt32 (field_number, uint32 value, output);
|
||||
static void WriteUInt64 (field_number, uint64 value, output);
|
||||
static void WriteSInt32 (field_number, int32 value, output);
|
||||
static void WriteSInt64 (field_number, int64 value, output);
|
||||
static void WriteFixed32 (field_number, uint32 value, output);
|
||||
static void WriteFixed64 (field_number, uint64 value, output);
|
||||
static void WriteSFixed32(field_number, int32 value, output);
|
||||
static void WriteSFixed64(field_number, int64 value, output);
|
||||
static void WriteFloat (field_number, float value, output);
|
||||
static void WriteDouble (field_number, double value, output);
|
||||
static void WriteBool (field_number, bool value, output);
|
||||
static void WriteEnum (field_number, int value, output);
|
||||
|
||||
static void WriteString(field_number, const string& value, output);
|
||||
static void WriteBytes (field_number, const string& value, output);
|
||||
|
||||
static void WriteGroup(
|
||||
field_number, const MessageLite& value, output);
|
||||
static void WriteMessage(
|
||||
field_number, const MessageLite& value, output);
|
||||
// Like above, but these will check if the output stream has enough
|
||||
// space to write directly to a flat array.
|
||||
static void WriteGroupMaybeToArray(
|
||||
field_number, const MessageLite& value, output);
|
||||
static void WriteMessageMaybeToArray(
|
||||
field_number, const MessageLite& value, output);
|
||||
|
||||
// Like above, but de-virtualize the call to SerializeWithCachedSizes(). The
|
||||
// pointer must point at an instance of MessageType, *not* a subclass (or
|
||||
// the subclass must not override SerializeWithCachedSizes()).
|
||||
template<typename MessageType>
|
||||
static inline void WriteGroupNoVirtual(
|
||||
field_number, const MessageType& value, output);
|
||||
template<typename MessageType>
|
||||
static inline void WriteMessageNoVirtual(
|
||||
field_number, const MessageType& value, output);
|
||||
|
||||
#undef output
|
||||
#define output uint8* target
|
||||
|
||||
// Like above, but use only *ToArray methods of CodedOutputStream.
|
||||
static inline uint8* WriteTagToArray(field_number, WireType type, output) INL;
|
||||
|
||||
// Write fields, without tags.
|
||||
static inline uint8* WriteInt32NoTagToArray (int32 value, output) INL;
|
||||
static inline uint8* WriteInt64NoTagToArray (int64 value, output) INL;
|
||||
static inline uint8* WriteUInt32NoTagToArray (uint32 value, output) INL;
|
||||
static inline uint8* WriteUInt64NoTagToArray (uint64 value, output) INL;
|
||||
static inline uint8* WriteSInt32NoTagToArray (int32 value, output) INL;
|
||||
static inline uint8* WriteSInt64NoTagToArray (int64 value, output) INL;
|
||||
static inline uint8* WriteFixed32NoTagToArray (uint32 value, output) INL;
|
||||
static inline uint8* WriteFixed64NoTagToArray (uint64 value, output) INL;
|
||||
static inline uint8* WriteSFixed32NoTagToArray(int32 value, output) INL;
|
||||
static inline uint8* WriteSFixed64NoTagToArray(int64 value, output) INL;
|
||||
static inline uint8* WriteFloatNoTagToArray (float value, output) INL;
|
||||
static inline uint8* WriteDoubleNoTagToArray (double value, output) INL;
|
||||
static inline uint8* WriteBoolNoTagToArray (bool value, output) INL;
|
||||
static inline uint8* WriteEnumNoTagToArray (int value, output) INL;
|
||||
|
||||
// Write fields, including tags.
|
||||
static inline uint8* WriteInt32ToArray(
|
||||
field_number, int32 value, output) INL;
|
||||
static inline uint8* WriteInt64ToArray(
|
||||
field_number, int64 value, output) INL;
|
||||
static inline uint8* WriteUInt32ToArray(
|
||||
field_number, uint32 value, output) INL;
|
||||
static inline uint8* WriteUInt64ToArray(
|
||||
field_number, uint64 value, output) INL;
|
||||
static inline uint8* WriteSInt32ToArray(
|
||||
field_number, int32 value, output) INL;
|
||||
static inline uint8* WriteSInt64ToArray(
|
||||
field_number, int64 value, output) INL;
|
||||
static inline uint8* WriteFixed32ToArray(
|
||||
field_number, uint32 value, output) INL;
|
||||
static inline uint8* WriteFixed64ToArray(
|
||||
field_number, uint64 value, output) INL;
|
||||
static inline uint8* WriteSFixed32ToArray(
|
||||
field_number, int32 value, output) INL;
|
||||
static inline uint8* WriteSFixed64ToArray(
|
||||
field_number, int64 value, output) INL;
|
||||
static inline uint8* WriteFloatToArray(
|
||||
field_number, float value, output) INL;
|
||||
static inline uint8* WriteDoubleToArray(
|
||||
field_number, double value, output) INL;
|
||||
static inline uint8* WriteBoolToArray(
|
||||
field_number, bool value, output) INL;
|
||||
static inline uint8* WriteEnumToArray(
|
||||
field_number, int value, output) INL;
|
||||
|
||||
static inline uint8* WriteStringToArray(
|
||||
field_number, const string& value, output) INL;
|
||||
static inline uint8* WriteBytesToArray(
|
||||
field_number, const string& value, output) INL;
|
||||
|
||||
static inline uint8* WriteGroupToArray(
|
||||
field_number, const MessageLite& value, output) INL;
|
||||
static inline uint8* WriteMessageToArray(
|
||||
field_number, const MessageLite& value, output) INL;
|
||||
|
||||
// Like above, but de-virtualize the call to SerializeWithCachedSizes(). The
|
||||
// pointer must point at an instance of MessageType, *not* a subclass (or
|
||||
// the subclass must not override SerializeWithCachedSizes()).
|
||||
template<typename MessageType>
|
||||
static inline uint8* WriteGroupNoVirtualToArray(
|
||||
field_number, const MessageType& value, output) INL;
|
||||
template<typename MessageType>
|
||||
static inline uint8* WriteMessageNoVirtualToArray(
|
||||
field_number, const MessageType& value, output) INL;
|
||||
|
||||
#undef output
|
||||
#undef input
|
||||
#undef INL
|
||||
|
||||
#undef field_number
|
||||
|
||||
// Compute the byte size of a field. The XxSize() functions do NOT include
|
||||
// the tag, so you must also call TagSize(). (This is because, for repeated
|
||||
// fields, you should only call TagSize() once and multiply it by the element
|
||||
// count, but you may have to call XxSize() for each individual element.)
|
||||
static inline int Int32Size ( int32 value);
|
||||
static inline int Int64Size ( int64 value);
|
||||
static inline int UInt32Size (uint32 value);
|
||||
static inline int UInt64Size (uint64 value);
|
||||
static inline int SInt32Size ( int32 value);
|
||||
static inline int SInt64Size ( int64 value);
|
||||
static inline int EnumSize ( int value);
|
||||
|
||||
// These types always have the same size.
|
||||
static const int kFixed32Size = 4;
|
||||
static const int kFixed64Size = 8;
|
||||
static const int kSFixed32Size = 4;
|
||||
static const int kSFixed64Size = 8;
|
||||
static const int kFloatSize = 4;
|
||||
static const int kDoubleSize = 8;
|
||||
static const int kBoolSize = 1;
|
||||
|
||||
static inline int StringSize(const string& value);
|
||||
static inline int BytesSize (const string& value);
|
||||
|
||||
static inline int GroupSize (const MessageLite& value);
|
||||
static inline int MessageSize(const MessageLite& value);
|
||||
|
||||
// Like above, but de-virtualize the call to ByteSize(). The
|
||||
// pointer must point at an instance of MessageType, *not* a subclass (or
|
||||
// the subclass must not override ByteSize()).
|
||||
template<typename MessageType>
|
||||
static inline int GroupSizeNoVirtual (const MessageType& value);
|
||||
template<typename MessageType>
|
||||
static inline int MessageSizeNoVirtual(const MessageType& value);
|
||||
|
||||
private:
|
||||
// A helper method for the repeated primitive reader. This method has
|
||||
// optimizations for primitive types that have fixed size on the wire, and
|
||||
// can be read using potentially faster paths.
|
||||
template <typename CType, enum FieldType DeclaredType>
|
||||
static inline bool ReadRepeatedFixedSizePrimitive(
|
||||
int tag_size,
|
||||
uint32 tag,
|
||||
google::protobuf::io::CodedInputStream* input,
|
||||
RepeatedField<CType>* value) GOOGLE_ATTRIBUTE_ALWAYS_INLINE;
|
||||
|
||||
static const CppType kFieldTypeToCppTypeMap[];
|
||||
static const WireFormatLite::WireType kWireTypeForFieldType[];
|
||||
|
||||
GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(WireFormatLite);
|
||||
};
|
||||
|
||||
// A class which deals with unknown values. The default implementation just
|
||||
// discards them. WireFormat defines a subclass which writes to an
|
||||
// UnknownFieldSet. This class is used by ExtensionSet::ParseField(), since
|
||||
// ExtensionSet is part of the lite library but UnknownFieldSet is not.
|
||||
class LIBPROTOBUF_EXPORT FieldSkipper {
|
||||
public:
|
||||
FieldSkipper() {}
|
||||
virtual ~FieldSkipper() {}
|
||||
|
||||
// Skip a field whose tag has already been consumed.
|
||||
virtual bool SkipField(io::CodedInputStream* input, uint32 tag);
|
||||
|
||||
// Skip an entire message or group, up to an end-group tag (which is consumed)
|
||||
// or end-of-stream.
|
||||
virtual bool SkipMessage(io::CodedInputStream* input);
|
||||
|
||||
// Deal with an already-parsed unrecognized enum value. The default
|
||||
// implementation does nothing, but the UnknownFieldSet-based implementation
|
||||
// saves it as an unknown varint.
|
||||
virtual void SkipUnknownEnum(int field_number, int value);
|
||||
};
|
||||
|
||||
// inline methods ====================================================
|
||||
|
||||
inline WireFormatLite::CppType
|
||||
WireFormatLite::FieldTypeToCppType(FieldType type) {
|
||||
return kFieldTypeToCppTypeMap[type];
|
||||
}
|
||||
|
||||
inline uint32 WireFormatLite::MakeTag(int field_number, WireType type) {
|
||||
return GOOGLE_PROTOBUF_WIRE_FORMAT_MAKE_TAG(field_number, type);
|
||||
}
|
||||
|
||||
inline WireFormatLite::WireType WireFormatLite::GetTagWireType(uint32 tag) {
|
||||
return static_cast<WireType>(tag & kTagTypeMask);
|
||||
}
|
||||
|
||||
inline int WireFormatLite::GetTagFieldNumber(uint32 tag) {
|
||||
return static_cast<int>(tag >> kTagTypeBits);
|
||||
}
|
||||
|
||||
inline int WireFormatLite::TagSize(int field_number,
|
||||
WireFormatLite::FieldType type) {
|
||||
int result = io::CodedOutputStream::VarintSize32(
|
||||
field_number << kTagTypeBits);
|
||||
if (type == TYPE_GROUP) {
|
||||
// Groups have both a start and an end tag.
|
||||
return result * 2;
|
||||
} else {
|
||||
return result;
|
||||
}
|
||||
}
|
||||
|
||||
inline uint32 WireFormatLite::EncodeFloat(float value) {
|
||||
union {float f; uint32 i;};
|
||||
f = value;
|
||||
return i;
|
||||
}
|
||||
|
||||
inline float WireFormatLite::DecodeFloat(uint32 value) {
|
||||
union {float f; uint32 i;};
|
||||
i = value;
|
||||
return f;
|
||||
}
|
||||
|
||||
inline uint64 WireFormatLite::EncodeDouble(double value) {
|
||||
union {double f; uint64 i;};
|
||||
f = value;
|
||||
return i;
|
||||
}
|
||||
|
||||
inline double WireFormatLite::DecodeDouble(uint64 value) {
|
||||
union {double f; uint64 i;};
|
||||
i = value;
|
||||
return f;
|
||||
}
|
||||
|
||||
// ZigZag Transform: Encodes signed integers so that they can be
|
||||
// effectively used with varint encoding.
|
||||
//
|
||||
// varint operates on unsigned integers, encoding smaller numbers into
|
||||
// fewer bytes. If you try to use it on a signed integer, it will treat
|
||||
// this number as a very large unsigned integer, which means that even
|
||||
// small signed numbers like -1 will take the maximum number of bytes
|
||||
// (10) to encode. ZigZagEncode() maps signed integers to unsigned
|
||||
// in such a way that those with a small absolute value will have smaller
|
||||
// encoded values, making them appropriate for encoding using varint.
|
||||
//
|
||||
// int32 -> uint32
|
||||
// -------------------------
|
||||
// 0 -> 0
|
||||
// -1 -> 1
|
||||
// 1 -> 2
|
||||
// -2 -> 3
|
||||
// ... -> ...
|
||||
// 2147483647 -> 4294967294
|
||||
// -2147483648 -> 4294967295
|
||||
//
|
||||
// >> encode >>
|
||||
// << decode <<
|
||||
|
||||
inline uint32 WireFormatLite::ZigZagEncode32(int32 n) {
|
||||
// Note: the right-shift must be arithmetic
|
||||
return (n << 1) ^ (n >> 31);
|
||||
}
|
||||
|
||||
inline int32 WireFormatLite::ZigZagDecode32(uint32 n) {
|
||||
return (n >> 1) ^ -static_cast<int32>(n & 1);
|
||||
}
|
||||
|
||||
inline uint64 WireFormatLite::ZigZagEncode64(int64 n) {
|
||||
// Note: the right-shift must be arithmetic
|
||||
return (n << 1) ^ (n >> 63);
|
||||
}
|
||||
|
||||
inline int64 WireFormatLite::ZigZagDecode64(uint64 n) {
|
||||
return (n >> 1) ^ -static_cast<int64>(n & 1);
|
||||
}
|
||||
|
||||
} // namespace internal
|
||||
} // namespace protobuf
|
||||
|
||||
} // namespace google
|
||||
#endif // GOOGLE_PROTOBUF_WIRE_FORMAT_LITE_H__
|
||||
@ -1,774 +0,0 @@
|
||||
// Protocol Buffers - Google's data interchange format
|
||||
// Copyright 2008 Google Inc. All rights reserved.
|
||||
// http://code.google.com/p/protobuf/
|
||||
//
|
||||
// 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.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// 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.
|
||||
|
||||
// Author: kenton@google.com (Kenton Varda)
|
||||
// wink@google.com (Wink Saville) (refactored from wire_format.h)
|
||||
// Based on original Protocol Buffers design by
|
||||
// Sanjay Ghemawat, Jeff Dean, and others.
|
||||
|
||||
#ifndef GOOGLE_PROTOBUF_WIRE_FORMAT_LITE_INL_H__
|
||||
#define GOOGLE_PROTOBUF_WIRE_FORMAT_LITE_INL_H__
|
||||
|
||||
#include <string>
|
||||
#include <google/protobuf/stubs/common.h>
|
||||
#include <google/protobuf/message_lite.h>
|
||||
#include <google/protobuf/repeated_field.h>
|
||||
#include <google/protobuf/wire_format_lite.h>
|
||||
#include <google/protobuf/generated_message_util.h>
|
||||
#include <google/protobuf/io/coded_stream.h>
|
||||
|
||||
|
||||
namespace google {
|
||||
namespace protobuf {
|
||||
namespace internal {
|
||||
|
||||
// Implementation details of ReadPrimitive.
|
||||
|
||||
template <>
|
||||
inline bool WireFormatLite::ReadPrimitive<int32, WireFormatLite::TYPE_INT32>(
|
||||
io::CodedInputStream* input,
|
||||
int32* value) {
|
||||
uint32 temp;
|
||||
if (!input->ReadVarint32(&temp)) return false;
|
||||
*value = static_cast<int32>(temp);
|
||||
return true;
|
||||
}
|
||||
template <>
|
||||
inline bool WireFormatLite::ReadPrimitive<int64, WireFormatLite::TYPE_INT64>(
|
||||
io::CodedInputStream* input,
|
||||
int64* value) {
|
||||
uint64 temp;
|
||||
if (!input->ReadVarint64(&temp)) return false;
|
||||
*value = static_cast<int64>(temp);
|
||||
return true;
|
||||
}
|
||||
template <>
|
||||
inline bool WireFormatLite::ReadPrimitive<uint32, WireFormatLite::TYPE_UINT32>(
|
||||
io::CodedInputStream* input,
|
||||
uint32* value) {
|
||||
return input->ReadVarint32(value);
|
||||
}
|
||||
template <>
|
||||
inline bool WireFormatLite::ReadPrimitive<uint64, WireFormatLite::TYPE_UINT64>(
|
||||
io::CodedInputStream* input,
|
||||
uint64* value) {
|
||||
return input->ReadVarint64(value);
|
||||
}
|
||||
template <>
|
||||
inline bool WireFormatLite::ReadPrimitive<int32, WireFormatLite::TYPE_SINT32>(
|
||||
io::CodedInputStream* input,
|
||||
int32* value) {
|
||||
uint32 temp;
|
||||
if (!input->ReadVarint32(&temp)) return false;
|
||||
*value = ZigZagDecode32(temp);
|
||||
return true;
|
||||
}
|
||||
template <>
|
||||
inline bool WireFormatLite::ReadPrimitive<int64, WireFormatLite::TYPE_SINT64>(
|
||||
io::CodedInputStream* input,
|
||||
int64* value) {
|
||||
uint64 temp;
|
||||
if (!input->ReadVarint64(&temp)) return false;
|
||||
*value = ZigZagDecode64(temp);
|
||||
return true;
|
||||
}
|
||||
template <>
|
||||
inline bool WireFormatLite::ReadPrimitive<uint32, WireFormatLite::TYPE_FIXED32>(
|
||||
io::CodedInputStream* input,
|
||||
uint32* value) {
|
||||
return input->ReadLittleEndian32(value);
|
||||
}
|
||||
template <>
|
||||
inline bool WireFormatLite::ReadPrimitive<uint64, WireFormatLite::TYPE_FIXED64>(
|
||||
io::CodedInputStream* input,
|
||||
uint64* value) {
|
||||
return input->ReadLittleEndian64(value);
|
||||
}
|
||||
template <>
|
||||
inline bool WireFormatLite::ReadPrimitive<int32, WireFormatLite::TYPE_SFIXED32>(
|
||||
io::CodedInputStream* input,
|
||||
int32* value) {
|
||||
uint32 temp;
|
||||
if (!input->ReadLittleEndian32(&temp)) return false;
|
||||
*value = static_cast<int32>(temp);
|
||||
return true;
|
||||
}
|
||||
template <>
|
||||
inline bool WireFormatLite::ReadPrimitive<int64, WireFormatLite::TYPE_SFIXED64>(
|
||||
io::CodedInputStream* input,
|
||||
int64* value) {
|
||||
uint64 temp;
|
||||
if (!input->ReadLittleEndian64(&temp)) return false;
|
||||
*value = static_cast<int64>(temp);
|
||||
return true;
|
||||
}
|
||||
template <>
|
||||
inline bool WireFormatLite::ReadPrimitive<float, WireFormatLite::TYPE_FLOAT>(
|
||||
io::CodedInputStream* input,
|
||||
float* value) {
|
||||
uint32 temp;
|
||||
if (!input->ReadLittleEndian32(&temp)) return false;
|
||||
*value = DecodeFloat(temp);
|
||||
return true;
|
||||
}
|
||||
template <>
|
||||
inline bool WireFormatLite::ReadPrimitive<double, WireFormatLite::TYPE_DOUBLE>(
|
||||
io::CodedInputStream* input,
|
||||
double* value) {
|
||||
uint64 temp;
|
||||
if (!input->ReadLittleEndian64(&temp)) return false;
|
||||
*value = DecodeDouble(temp);
|
||||
return true;
|
||||
}
|
||||
template <>
|
||||
inline bool WireFormatLite::ReadPrimitive<bool, WireFormatLite::TYPE_BOOL>(
|
||||
io::CodedInputStream* input,
|
||||
bool* value) {
|
||||
uint32 temp;
|
||||
if (!input->ReadVarint32(&temp)) return false;
|
||||
*value = temp != 0;
|
||||
return true;
|
||||
}
|
||||
template <>
|
||||
inline bool WireFormatLite::ReadPrimitive<int, WireFormatLite::TYPE_ENUM>(
|
||||
io::CodedInputStream* input,
|
||||
int* value) {
|
||||
uint32 temp;
|
||||
if (!input->ReadVarint32(&temp)) return false;
|
||||
*value = static_cast<int>(temp);
|
||||
return true;
|
||||
}
|
||||
|
||||
template <>
|
||||
inline const uint8* WireFormatLite::ReadPrimitiveFromArray<
|
||||
uint32, WireFormatLite::TYPE_FIXED32>(
|
||||
const uint8* buffer,
|
||||
uint32* value) {
|
||||
return io::CodedInputStream::ReadLittleEndian32FromArray(buffer, value);
|
||||
}
|
||||
template <>
|
||||
inline const uint8* WireFormatLite::ReadPrimitiveFromArray<
|
||||
uint64, WireFormatLite::TYPE_FIXED64>(
|
||||
const uint8* buffer,
|
||||
uint64* value) {
|
||||
return io::CodedInputStream::ReadLittleEndian64FromArray(buffer, value);
|
||||
}
|
||||
template <>
|
||||
inline const uint8* WireFormatLite::ReadPrimitiveFromArray<
|
||||
int32, WireFormatLite::TYPE_SFIXED32>(
|
||||
const uint8* buffer,
|
||||
int32* value) {
|
||||
uint32 temp;
|
||||
buffer = io::CodedInputStream::ReadLittleEndian32FromArray(buffer, &temp);
|
||||
*value = static_cast<int32>(temp);
|
||||
return buffer;
|
||||
}
|
||||
template <>
|
||||
inline const uint8* WireFormatLite::ReadPrimitiveFromArray<
|
||||
int64, WireFormatLite::TYPE_SFIXED64>(
|
||||
const uint8* buffer,
|
||||
int64* value) {
|
||||
uint64 temp;
|
||||
buffer = io::CodedInputStream::ReadLittleEndian64FromArray(buffer, &temp);
|
||||
*value = static_cast<int64>(temp);
|
||||
return buffer;
|
||||
}
|
||||
template <>
|
||||
inline const uint8* WireFormatLite::ReadPrimitiveFromArray<
|
||||
float, WireFormatLite::TYPE_FLOAT>(
|
||||
const uint8* buffer,
|
||||
float* value) {
|
||||
uint32 temp;
|
||||
buffer = io::CodedInputStream::ReadLittleEndian32FromArray(buffer, &temp);
|
||||
*value = DecodeFloat(temp);
|
||||
return buffer;
|
||||
}
|
||||
template <>
|
||||
inline const uint8* WireFormatLite::ReadPrimitiveFromArray<
|
||||
double, WireFormatLite::TYPE_DOUBLE>(
|
||||
const uint8* buffer,
|
||||
double* value) {
|
||||
uint64 temp;
|
||||
buffer = io::CodedInputStream::ReadLittleEndian64FromArray(buffer, &temp);
|
||||
*value = DecodeDouble(temp);
|
||||
return buffer;
|
||||
}
|
||||
|
||||
template <typename CType, enum WireFormatLite::FieldType DeclaredType>
|
||||
inline bool WireFormatLite::ReadRepeatedPrimitive(int, // tag_size, unused.
|
||||
uint32 tag,
|
||||
io::CodedInputStream* input,
|
||||
RepeatedField<CType>* values) {
|
||||
CType value;
|
||||
if (!ReadPrimitive<CType, DeclaredType>(input, &value)) return false;
|
||||
values->Add(value);
|
||||
int elements_already_reserved = values->Capacity() - values->size();
|
||||
while (elements_already_reserved > 0 && input->ExpectTag(tag)) {
|
||||
if (!ReadPrimitive<CType, DeclaredType>(input, &value)) return false;
|
||||
values->AddAlreadyReserved(value);
|
||||
elements_already_reserved--;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
template <typename CType, enum WireFormatLite::FieldType DeclaredType>
|
||||
inline bool WireFormatLite::ReadRepeatedFixedSizePrimitive(
|
||||
int tag_size,
|
||||
uint32 tag,
|
||||
io::CodedInputStream* input,
|
||||
RepeatedField<CType>* values) {
|
||||
GOOGLE_DCHECK_EQ(UInt32Size(tag), tag_size);
|
||||
CType value;
|
||||
if (!ReadPrimitive<CType, DeclaredType>(input, &value))
|
||||
return false;
|
||||
values->Add(value);
|
||||
|
||||
// For fixed size values, repeated values can be read more quickly by
|
||||
// reading directly from a raw array.
|
||||
//
|
||||
// We can get a tight loop by only reading as many elements as can be
|
||||
// added to the RepeatedField without having to do any resizing. Additionally,
|
||||
// we only try to read as many elements as are available from the current
|
||||
// buffer space. Doing so avoids having to perform boundary checks when
|
||||
// reading the value: the maximum number of elements that can be read is
|
||||
// known outside of the loop.
|
||||
const void* void_pointer;
|
||||
int size;
|
||||
input->GetDirectBufferPointerInline(&void_pointer, &size);
|
||||
if (size > 0) {
|
||||
const uint8* buffer = reinterpret_cast<const uint8*>(void_pointer);
|
||||
// The number of bytes each type occupies on the wire.
|
||||
const int per_value_size = tag_size + sizeof(value);
|
||||
|
||||
int elements_available = min(values->Capacity() - values->size(),
|
||||
size / per_value_size);
|
||||
int num_read = 0;
|
||||
while (num_read < elements_available &&
|
||||
(buffer = io::CodedInputStream::ExpectTagFromArray(
|
||||
buffer, tag)) != NULL) {
|
||||
buffer = ReadPrimitiveFromArray<CType, DeclaredType>(buffer, &value);
|
||||
values->AddAlreadyReserved(value);
|
||||
++num_read;
|
||||
}
|
||||
const int read_bytes = num_read * per_value_size;
|
||||
if (read_bytes > 0) {
|
||||
input->Skip(read_bytes);
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
// Specializations of ReadRepeatedPrimitive for the fixed size types, which use
|
||||
// the optimized code path.
|
||||
#define READ_REPEATED_FIXED_SIZE_PRIMITIVE(CPPTYPE, DECLARED_TYPE) \
|
||||
template <> \
|
||||
inline bool WireFormatLite::ReadRepeatedPrimitive< \
|
||||
CPPTYPE, WireFormatLite::DECLARED_TYPE>( \
|
||||
int tag_size, \
|
||||
uint32 tag, \
|
||||
io::CodedInputStream* input, \
|
||||
RepeatedField<CPPTYPE>* values) { \
|
||||
return ReadRepeatedFixedSizePrimitive< \
|
||||
CPPTYPE, WireFormatLite::DECLARED_TYPE>( \
|
||||
tag_size, tag, input, values); \
|
||||
}
|
||||
|
||||
READ_REPEATED_FIXED_SIZE_PRIMITIVE(uint32, TYPE_FIXED32);
|
||||
READ_REPEATED_FIXED_SIZE_PRIMITIVE(uint64, TYPE_FIXED64);
|
||||
READ_REPEATED_FIXED_SIZE_PRIMITIVE(int32, TYPE_SFIXED32);
|
||||
READ_REPEATED_FIXED_SIZE_PRIMITIVE(int64, TYPE_SFIXED64);
|
||||
READ_REPEATED_FIXED_SIZE_PRIMITIVE(float, TYPE_FLOAT);
|
||||
READ_REPEATED_FIXED_SIZE_PRIMITIVE(double, TYPE_DOUBLE);
|
||||
|
||||
#undef READ_REPEATED_FIXED_SIZE_PRIMITIVE
|
||||
|
||||
template <typename CType, enum WireFormatLite::FieldType DeclaredType>
|
||||
bool WireFormatLite::ReadRepeatedPrimitiveNoInline(
|
||||
int tag_size,
|
||||
uint32 tag,
|
||||
io::CodedInputStream* input,
|
||||
RepeatedField<CType>* value) {
|
||||
return ReadRepeatedPrimitive<CType, DeclaredType>(
|
||||
tag_size, tag, input, value);
|
||||
}
|
||||
|
||||
template <typename CType, enum WireFormatLite::FieldType DeclaredType>
|
||||
inline bool WireFormatLite::ReadPackedPrimitive(io::CodedInputStream* input,
|
||||
RepeatedField<CType>* values) {
|
||||
uint32 length;
|
||||
if (!input->ReadVarint32(&length)) return false;
|
||||
io::CodedInputStream::Limit limit = input->PushLimit(length);
|
||||
while (input->BytesUntilLimit() > 0) {
|
||||
CType value;
|
||||
if (!ReadPrimitive<CType, DeclaredType>(input, &value)) return false;
|
||||
values->Add(value);
|
||||
}
|
||||
input->PopLimit(limit);
|
||||
return true;
|
||||
}
|
||||
|
||||
template <typename CType, enum WireFormatLite::FieldType DeclaredType>
|
||||
bool WireFormatLite::ReadPackedPrimitiveNoInline(io::CodedInputStream* input,
|
||||
RepeatedField<CType>* values) {
|
||||
return ReadPackedPrimitive<CType, DeclaredType>(input, values);
|
||||
}
|
||||
|
||||
|
||||
inline bool WireFormatLite::ReadGroup(int field_number,
|
||||
io::CodedInputStream* input,
|
||||
MessageLite* value) {
|
||||
if (!input->IncrementRecursionDepth()) return false;
|
||||
if (!value->MergePartialFromCodedStream(input)) return false;
|
||||
input->DecrementRecursionDepth();
|
||||
// Make sure the last thing read was an end tag for this group.
|
||||
if (!input->LastTagWas(MakeTag(field_number, WIRETYPE_END_GROUP))) {
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
inline bool WireFormatLite::ReadMessage(io::CodedInputStream* input,
|
||||
MessageLite* value) {
|
||||
uint32 length;
|
||||
if (!input->ReadVarint32(&length)) return false;
|
||||
if (!input->IncrementRecursionDepth()) return false;
|
||||
io::CodedInputStream::Limit limit = input->PushLimit(length);
|
||||
if (!value->MergePartialFromCodedStream(input)) return false;
|
||||
// Make sure that parsing stopped when the limit was hit, not at an endgroup
|
||||
// tag.
|
||||
if (!input->ConsumedEntireMessage()) return false;
|
||||
input->PopLimit(limit);
|
||||
input->DecrementRecursionDepth();
|
||||
return true;
|
||||
}
|
||||
|
||||
// We name the template parameter something long and extremely unlikely to occur
|
||||
// elsewhere because a *qualified* member access expression designed to avoid
|
||||
// virtual dispatch, C++03 [basic.lookup.classref] 3.4.5/4 requires that the
|
||||
// name of the qualifying class to be looked up both in the context of the full
|
||||
// expression (finding the template parameter) and in the context of the object
|
||||
// whose member we are accessing. This could potentially find a nested type
|
||||
// within that object. The standard goes on to require these names to refer to
|
||||
// the same entity, which this collision would violate. The lack of a safe way
|
||||
// to avoid this collision appears to be a defect in the standard, but until it
|
||||
// is corrected, we choose the name to avoid accidental collisions.
|
||||
template<typename MessageType_WorkAroundCppLookupDefect>
|
||||
inline bool WireFormatLite::ReadGroupNoVirtual(
|
||||
int field_number, io::CodedInputStream* input,
|
||||
MessageType_WorkAroundCppLookupDefect* value) {
|
||||
if (!input->IncrementRecursionDepth()) return false;
|
||||
if (!value->
|
||||
MessageType_WorkAroundCppLookupDefect::MergePartialFromCodedStream(input))
|
||||
return false;
|
||||
input->DecrementRecursionDepth();
|
||||
// Make sure the last thing read was an end tag for this group.
|
||||
if (!input->LastTagWas(MakeTag(field_number, WIRETYPE_END_GROUP))) {
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
template<typename MessageType_WorkAroundCppLookupDefect>
|
||||
inline bool WireFormatLite::ReadMessageNoVirtual(
|
||||
io::CodedInputStream* input, MessageType_WorkAroundCppLookupDefect* value) {
|
||||
uint32 length;
|
||||
if (!input->ReadVarint32(&length)) return false;
|
||||
if (!input->IncrementRecursionDepth()) return false;
|
||||
io::CodedInputStream::Limit limit = input->PushLimit(length);
|
||||
if (!value->
|
||||
MessageType_WorkAroundCppLookupDefect::MergePartialFromCodedStream(input))
|
||||
return false;
|
||||
// Make sure that parsing stopped when the limit was hit, not at an endgroup
|
||||
// tag.
|
||||
if (!input->ConsumedEntireMessage()) return false;
|
||||
input->PopLimit(limit);
|
||||
input->DecrementRecursionDepth();
|
||||
return true;
|
||||
}
|
||||
|
||||
// ===================================================================
|
||||
|
||||
inline void WireFormatLite::WriteTag(int field_number, WireType type,
|
||||
io::CodedOutputStream* output) {
|
||||
output->WriteTag(MakeTag(field_number, type));
|
||||
}
|
||||
|
||||
inline void WireFormatLite::WriteInt32NoTag(int32 value,
|
||||
io::CodedOutputStream* output) {
|
||||
output->WriteVarint32SignExtended(value);
|
||||
}
|
||||
inline void WireFormatLite::WriteInt64NoTag(int64 value,
|
||||
io::CodedOutputStream* output) {
|
||||
output->WriteVarint64(static_cast<uint64>(value));
|
||||
}
|
||||
inline void WireFormatLite::WriteUInt32NoTag(uint32 value,
|
||||
io::CodedOutputStream* output) {
|
||||
output->WriteVarint32(value);
|
||||
}
|
||||
inline void WireFormatLite::WriteUInt64NoTag(uint64 value,
|
||||
io::CodedOutputStream* output) {
|
||||
output->WriteVarint64(value);
|
||||
}
|
||||
inline void WireFormatLite::WriteSInt32NoTag(int32 value,
|
||||
io::CodedOutputStream* output) {
|
||||
output->WriteVarint32(ZigZagEncode32(value));
|
||||
}
|
||||
inline void WireFormatLite::WriteSInt64NoTag(int64 value,
|
||||
io::CodedOutputStream* output) {
|
||||
output->WriteVarint64(ZigZagEncode64(value));
|
||||
}
|
||||
inline void WireFormatLite::WriteFixed32NoTag(uint32 value,
|
||||
io::CodedOutputStream* output) {
|
||||
output->WriteLittleEndian32(value);
|
||||
}
|
||||
inline void WireFormatLite::WriteFixed64NoTag(uint64 value,
|
||||
io::CodedOutputStream* output) {
|
||||
output->WriteLittleEndian64(value);
|
||||
}
|
||||
inline void WireFormatLite::WriteSFixed32NoTag(int32 value,
|
||||
io::CodedOutputStream* output) {
|
||||
output->WriteLittleEndian32(static_cast<uint32>(value));
|
||||
}
|
||||
inline void WireFormatLite::WriteSFixed64NoTag(int64 value,
|
||||
io::CodedOutputStream* output) {
|
||||
output->WriteLittleEndian64(static_cast<uint64>(value));
|
||||
}
|
||||
inline void WireFormatLite::WriteFloatNoTag(float value,
|
||||
io::CodedOutputStream* output) {
|
||||
output->WriteLittleEndian32(EncodeFloat(value));
|
||||
}
|
||||
inline void WireFormatLite::WriteDoubleNoTag(double value,
|
||||
io::CodedOutputStream* output) {
|
||||
output->WriteLittleEndian64(EncodeDouble(value));
|
||||
}
|
||||
inline void WireFormatLite::WriteBoolNoTag(bool value,
|
||||
io::CodedOutputStream* output) {
|
||||
output->WriteVarint32(value ? 1 : 0);
|
||||
}
|
||||
inline void WireFormatLite::WriteEnumNoTag(int value,
|
||||
io::CodedOutputStream* output) {
|
||||
output->WriteVarint32SignExtended(value);
|
||||
}
|
||||
|
||||
// See comment on ReadGroupNoVirtual to understand the need for this template
|
||||
// parameter name.
|
||||
template<typename MessageType_WorkAroundCppLookupDefect>
|
||||
inline void WireFormatLite::WriteGroupNoVirtual(
|
||||
int field_number, const MessageType_WorkAroundCppLookupDefect& value,
|
||||
io::CodedOutputStream* output) {
|
||||
WriteTag(field_number, WIRETYPE_START_GROUP, output);
|
||||
value.MessageType_WorkAroundCppLookupDefect::SerializeWithCachedSizes(output);
|
||||
WriteTag(field_number, WIRETYPE_END_GROUP, output);
|
||||
}
|
||||
template<typename MessageType_WorkAroundCppLookupDefect>
|
||||
inline void WireFormatLite::WriteMessageNoVirtual(
|
||||
int field_number, const MessageType_WorkAroundCppLookupDefect& value,
|
||||
io::CodedOutputStream* output) {
|
||||
WriteTag(field_number, WIRETYPE_LENGTH_DELIMITED, output);
|
||||
output->WriteVarint32(
|
||||
value.MessageType_WorkAroundCppLookupDefect::GetCachedSize());
|
||||
value.MessageType_WorkAroundCppLookupDefect::SerializeWithCachedSizes(output);
|
||||
}
|
||||
|
||||
// ===================================================================
|
||||
|
||||
inline uint8* WireFormatLite::WriteTagToArray(int field_number,
|
||||
WireType type,
|
||||
uint8* target) {
|
||||
return io::CodedOutputStream::WriteTagToArray(MakeTag(field_number, type),
|
||||
target);
|
||||
}
|
||||
|
||||
inline uint8* WireFormatLite::WriteInt32NoTagToArray(int32 value,
|
||||
uint8* target) {
|
||||
return io::CodedOutputStream::WriteVarint32SignExtendedToArray(value, target);
|
||||
}
|
||||
inline uint8* WireFormatLite::WriteInt64NoTagToArray(int64 value,
|
||||
uint8* target) {
|
||||
return io::CodedOutputStream::WriteVarint64ToArray(
|
||||
static_cast<uint64>(value), target);
|
||||
}
|
||||
inline uint8* WireFormatLite::WriteUInt32NoTagToArray(uint32 value,
|
||||
uint8* target) {
|
||||
return io::CodedOutputStream::WriteVarint32ToArray(value, target);
|
||||
}
|
||||
inline uint8* WireFormatLite::WriteUInt64NoTagToArray(uint64 value,
|
||||
uint8* target) {
|
||||
return io::CodedOutputStream::WriteVarint64ToArray(value, target);
|
||||
}
|
||||
inline uint8* WireFormatLite::WriteSInt32NoTagToArray(int32 value,
|
||||
uint8* target) {
|
||||
return io::CodedOutputStream::WriteVarint32ToArray(ZigZagEncode32(value),
|
||||
target);
|
||||
}
|
||||
inline uint8* WireFormatLite::WriteSInt64NoTagToArray(int64 value,
|
||||
uint8* target) {
|
||||
return io::CodedOutputStream::WriteVarint64ToArray(ZigZagEncode64(value),
|
||||
target);
|
||||
}
|
||||
inline uint8* WireFormatLite::WriteFixed32NoTagToArray(uint32 value,
|
||||
uint8* target) {
|
||||
return io::CodedOutputStream::WriteLittleEndian32ToArray(value, target);
|
||||
}
|
||||
inline uint8* WireFormatLite::WriteFixed64NoTagToArray(uint64 value,
|
||||
uint8* target) {
|
||||
return io::CodedOutputStream::WriteLittleEndian64ToArray(value, target);
|
||||
}
|
||||
inline uint8* WireFormatLite::WriteSFixed32NoTagToArray(int32 value,
|
||||
uint8* target) {
|
||||
return io::CodedOutputStream::WriteLittleEndian32ToArray(
|
||||
static_cast<uint32>(value), target);
|
||||
}
|
||||
inline uint8* WireFormatLite::WriteSFixed64NoTagToArray(int64 value,
|
||||
uint8* target) {
|
||||
return io::CodedOutputStream::WriteLittleEndian64ToArray(
|
||||
static_cast<uint64>(value), target);
|
||||
}
|
||||
inline uint8* WireFormatLite::WriteFloatNoTagToArray(float value,
|
||||
uint8* target) {
|
||||
return io::CodedOutputStream::WriteLittleEndian32ToArray(EncodeFloat(value),
|
||||
target);
|
||||
}
|
||||
inline uint8* WireFormatLite::WriteDoubleNoTagToArray(double value,
|
||||
uint8* target) {
|
||||
return io::CodedOutputStream::WriteLittleEndian64ToArray(EncodeDouble(value),
|
||||
target);
|
||||
}
|
||||
inline uint8* WireFormatLite::WriteBoolNoTagToArray(bool value,
|
||||
uint8* target) {
|
||||
return io::CodedOutputStream::WriteVarint32ToArray(value ? 1 : 0, target);
|
||||
}
|
||||
inline uint8* WireFormatLite::WriteEnumNoTagToArray(int value,
|
||||
uint8* target) {
|
||||
return io::CodedOutputStream::WriteVarint32SignExtendedToArray(value, target);
|
||||
}
|
||||
|
||||
inline uint8* WireFormatLite::WriteInt32ToArray(int field_number,
|
||||
int32 value,
|
||||
uint8* target) {
|
||||
target = WriteTagToArray(field_number, WIRETYPE_VARINT, target);
|
||||
return WriteInt32NoTagToArray(value, target);
|
||||
}
|
||||
inline uint8* WireFormatLite::WriteInt64ToArray(int field_number,
|
||||
int64 value,
|
||||
uint8* target) {
|
||||
target = WriteTagToArray(field_number, WIRETYPE_VARINT, target);
|
||||
return WriteInt64NoTagToArray(value, target);
|
||||
}
|
||||
inline uint8* WireFormatLite::WriteUInt32ToArray(int field_number,
|
||||
uint32 value,
|
||||
uint8* target) {
|
||||
target = WriteTagToArray(field_number, WIRETYPE_VARINT, target);
|
||||
return WriteUInt32NoTagToArray(value, target);
|
||||
}
|
||||
inline uint8* WireFormatLite::WriteUInt64ToArray(int field_number,
|
||||
uint64 value,
|
||||
uint8* target) {
|
||||
target = WriteTagToArray(field_number, WIRETYPE_VARINT, target);
|
||||
return WriteUInt64NoTagToArray(value, target);
|
||||
}
|
||||
inline uint8* WireFormatLite::WriteSInt32ToArray(int field_number,
|
||||
int32 value,
|
||||
uint8* target) {
|
||||
target = WriteTagToArray(field_number, WIRETYPE_VARINT, target);
|
||||
return WriteSInt32NoTagToArray(value, target);
|
||||
}
|
||||
inline uint8* WireFormatLite::WriteSInt64ToArray(int field_number,
|
||||
int64 value,
|
||||
uint8* target) {
|
||||
target = WriteTagToArray(field_number, WIRETYPE_VARINT, target);
|
||||
return WriteSInt64NoTagToArray(value, target);
|
||||
}
|
||||
inline uint8* WireFormatLite::WriteFixed32ToArray(int field_number,
|
||||
uint32 value,
|
||||
uint8* target) {
|
||||
target = WriteTagToArray(field_number, WIRETYPE_FIXED32, target);
|
||||
return WriteFixed32NoTagToArray(value, target);
|
||||
}
|
||||
inline uint8* WireFormatLite::WriteFixed64ToArray(int field_number,
|
||||
uint64 value,
|
||||
uint8* target) {
|
||||
target = WriteTagToArray(field_number, WIRETYPE_FIXED64, target);
|
||||
return WriteFixed64NoTagToArray(value, target);
|
||||
}
|
||||
inline uint8* WireFormatLite::WriteSFixed32ToArray(int field_number,
|
||||
int32 value,
|
||||
uint8* target) {
|
||||
target = WriteTagToArray(field_number, WIRETYPE_FIXED32, target);
|
||||
return WriteSFixed32NoTagToArray(value, target);
|
||||
}
|
||||
inline uint8* WireFormatLite::WriteSFixed64ToArray(int field_number,
|
||||
int64 value,
|
||||
uint8* target) {
|
||||
target = WriteTagToArray(field_number, WIRETYPE_FIXED64, target);
|
||||
return WriteSFixed64NoTagToArray(value, target);
|
||||
}
|
||||
inline uint8* WireFormatLite::WriteFloatToArray(int field_number,
|
||||
float value,
|
||||
uint8* target) {
|
||||
target = WriteTagToArray(field_number, WIRETYPE_FIXED32, target);
|
||||
return WriteFloatNoTagToArray(value, target);
|
||||
}
|
||||
inline uint8* WireFormatLite::WriteDoubleToArray(int field_number,
|
||||
double value,
|
||||
uint8* target) {
|
||||
target = WriteTagToArray(field_number, WIRETYPE_FIXED64, target);
|
||||
return WriteDoubleNoTagToArray(value, target);
|
||||
}
|
||||
inline uint8* WireFormatLite::WriteBoolToArray(int field_number,
|
||||
bool value,
|
||||
uint8* target) {
|
||||
target = WriteTagToArray(field_number, WIRETYPE_VARINT, target);
|
||||
return WriteBoolNoTagToArray(value, target);
|
||||
}
|
||||
inline uint8* WireFormatLite::WriteEnumToArray(int field_number,
|
||||
int value,
|
||||
uint8* target) {
|
||||
target = WriteTagToArray(field_number, WIRETYPE_VARINT, target);
|
||||
return WriteEnumNoTagToArray(value, target);
|
||||
}
|
||||
|
||||
inline uint8* WireFormatLite::WriteStringToArray(int field_number,
|
||||
const string& value,
|
||||
uint8* target) {
|
||||
// String is for UTF-8 text only
|
||||
// WARNING: In wire_format.cc, both strings and bytes are handled by
|
||||
// WriteString() to avoid code duplication. If the implementations become
|
||||
// different, you will need to update that usage.
|
||||
target = WriteTagToArray(field_number, WIRETYPE_LENGTH_DELIMITED, target);
|
||||
target = io::CodedOutputStream::WriteVarint32ToArray(value.size(), target);
|
||||
return io::CodedOutputStream::WriteStringToArray(value, target);
|
||||
}
|
||||
inline uint8* WireFormatLite::WriteBytesToArray(int field_number,
|
||||
const string& value,
|
||||
uint8* target) {
|
||||
target = WriteTagToArray(field_number, WIRETYPE_LENGTH_DELIMITED, target);
|
||||
target = io::CodedOutputStream::WriteVarint32ToArray(value.size(), target);
|
||||
return io::CodedOutputStream::WriteStringToArray(value, target);
|
||||
}
|
||||
|
||||
|
||||
inline uint8* WireFormatLite::WriteGroupToArray(int field_number,
|
||||
const MessageLite& value,
|
||||
uint8* target) {
|
||||
target = WriteTagToArray(field_number, WIRETYPE_START_GROUP, target);
|
||||
target = value.SerializeWithCachedSizesToArray(target);
|
||||
return WriteTagToArray(field_number, WIRETYPE_END_GROUP, target);
|
||||
}
|
||||
inline uint8* WireFormatLite::WriteMessageToArray(int field_number,
|
||||
const MessageLite& value,
|
||||
uint8* target) {
|
||||
target = WriteTagToArray(field_number, WIRETYPE_LENGTH_DELIMITED, target);
|
||||
target = io::CodedOutputStream::WriteVarint32ToArray(
|
||||
value.GetCachedSize(), target);
|
||||
return value.SerializeWithCachedSizesToArray(target);
|
||||
}
|
||||
|
||||
// See comment on ReadGroupNoVirtual to understand the need for this template
|
||||
// parameter name.
|
||||
template<typename MessageType_WorkAroundCppLookupDefect>
|
||||
inline uint8* WireFormatLite::WriteGroupNoVirtualToArray(
|
||||
int field_number, const MessageType_WorkAroundCppLookupDefect& value,
|
||||
uint8* target) {
|
||||
target = WriteTagToArray(field_number, WIRETYPE_START_GROUP, target);
|
||||
target = value.MessageType_WorkAroundCppLookupDefect
|
||||
::SerializeWithCachedSizesToArray(target);
|
||||
return WriteTagToArray(field_number, WIRETYPE_END_GROUP, target);
|
||||
}
|
||||
template<typename MessageType_WorkAroundCppLookupDefect>
|
||||
inline uint8* WireFormatLite::WriteMessageNoVirtualToArray(
|
||||
int field_number, const MessageType_WorkAroundCppLookupDefect& value,
|
||||
uint8* target) {
|
||||
target = WriteTagToArray(field_number, WIRETYPE_LENGTH_DELIMITED, target);
|
||||
target = io::CodedOutputStream::WriteVarint32ToArray(
|
||||
value.MessageType_WorkAroundCppLookupDefect::GetCachedSize(), target);
|
||||
return value.MessageType_WorkAroundCppLookupDefect
|
||||
::SerializeWithCachedSizesToArray(target);
|
||||
}
|
||||
|
||||
// ===================================================================
|
||||
|
||||
inline int WireFormatLite::Int32Size(int32 value) {
|
||||
return io::CodedOutputStream::VarintSize32SignExtended(value);
|
||||
}
|
||||
inline int WireFormatLite::Int64Size(int64 value) {
|
||||
return io::CodedOutputStream::VarintSize64(static_cast<uint64>(value));
|
||||
}
|
||||
inline int WireFormatLite::UInt32Size(uint32 value) {
|
||||
return io::CodedOutputStream::VarintSize32(value);
|
||||
}
|
||||
inline int WireFormatLite::UInt64Size(uint64 value) {
|
||||
return io::CodedOutputStream::VarintSize64(value);
|
||||
}
|
||||
inline int WireFormatLite::SInt32Size(int32 value) {
|
||||
return io::CodedOutputStream::VarintSize32(ZigZagEncode32(value));
|
||||
}
|
||||
inline int WireFormatLite::SInt64Size(int64 value) {
|
||||
return io::CodedOutputStream::VarintSize64(ZigZagEncode64(value));
|
||||
}
|
||||
inline int WireFormatLite::EnumSize(int value) {
|
||||
return io::CodedOutputStream::VarintSize32SignExtended(value);
|
||||
}
|
||||
|
||||
inline int WireFormatLite::StringSize(const string& value) {
|
||||
return io::CodedOutputStream::VarintSize32(value.size()) +
|
||||
value.size();
|
||||
}
|
||||
inline int WireFormatLite::BytesSize(const string& value) {
|
||||
return io::CodedOutputStream::VarintSize32(value.size()) +
|
||||
value.size();
|
||||
}
|
||||
|
||||
|
||||
inline int WireFormatLite::GroupSize(const MessageLite& value) {
|
||||
return value.ByteSize();
|
||||
}
|
||||
inline int WireFormatLite::MessageSize(const MessageLite& value) {
|
||||
int size = value.ByteSize();
|
||||
return io::CodedOutputStream::VarintSize32(size) + size;
|
||||
}
|
||||
|
||||
// See comment on ReadGroupNoVirtual to understand the need for this template
|
||||
// parameter name.
|
||||
template<typename MessageType_WorkAroundCppLookupDefect>
|
||||
inline int WireFormatLite::GroupSizeNoVirtual(
|
||||
const MessageType_WorkAroundCppLookupDefect& value) {
|
||||
return value.MessageType_WorkAroundCppLookupDefect::ByteSize();
|
||||
}
|
||||
template<typename MessageType_WorkAroundCppLookupDefect>
|
||||
inline int WireFormatLite::MessageSizeNoVirtual(
|
||||
const MessageType_WorkAroundCppLookupDefect& value) {
|
||||
int size = value.MessageType_WorkAroundCppLookupDefect::ByteSize();
|
||||
return io::CodedOutputStream::VarintSize32(size) + size;
|
||||
}
|
||||
|
||||
} // namespace internal
|
||||
} // namespace protobuf
|
||||
|
||||
} // namespace google
|
||||
#endif // GOOGLE_PROTOBUF_WIRE_FORMAT_LITE_INL_H__
|
||||
@ -0,0 +1,918 @@
|
||||
## Process this file with automake to produce Makefile.in
|
||||
|
||||
if HAVE_ZLIB
|
||||
GZCHECKPROGRAMS = zcgzip zcgunzip
|
||||
GZHEADERS = google/protobuf/io/gzip_stream.h
|
||||
GZTESTS = google/protobuf/io/gzip_stream_unittest.sh
|
||||
ZLIB_DEF = -DHAVE_ZLIB=1
|
||||
else
|
||||
GZCHECKPROGRAMS =
|
||||
GZHEADERS =
|
||||
GZTESTS =
|
||||
ZLIB_DEF =
|
||||
endif
|
||||
|
||||
if HAVE_PTHREAD
|
||||
PTHREAD_DEF = -DHAVE_PTHREAD=1
|
||||
else
|
||||
PTHREAD_DEF =
|
||||
endif
|
||||
|
||||
PROTOBUF_VERSION = 32:10:0
|
||||
|
||||
if GCC
|
||||
# Turn on all warnings except for sign comparison (we ignore sign comparison
|
||||
# in Google so our code base have tons of such warnings).
|
||||
NO_OPT_CXXFLAGS = $(PTHREAD_CFLAGS) $(PTHREAD_DEF) $(ZLIB_DEF) -Wall -Wno-sign-compare
|
||||
else
|
||||
NO_OPT_CXXFLAGS = $(PTHREAD_CFLAGS) $(PTHREAD_DEF) $(ZLIB_DEF)
|
||||
endif
|
||||
|
||||
AM_CXXFLAGS = $(NO_OPT_CXXFLAGS) $(PROTOBUF_OPT_FLAG)
|
||||
|
||||
AM_LDFLAGS = $(PTHREAD_CFLAGS) ${LIBLOG_LIBS}
|
||||
|
||||
# If I say "dist_include_DATA", automake complains that $(includedir) is not
|
||||
# a "legitimate" directory for DATA. Screw you, automake.
|
||||
protodir = $(includedir)
|
||||
|
||||
# If you are adding new files here, also remember to change the build files for
|
||||
# all other languages, //protoc-artifacts/build-zip.sh and run
|
||||
# //update_file_list.sh for bazel.
|
||||
nobase_dist_proto_DATA = \
|
||||
google/protobuf/any.proto \
|
||||
google/protobuf/api.proto \
|
||||
google/protobuf/compiler/plugin.proto \
|
||||
google/protobuf/descriptor.proto \
|
||||
google/protobuf/duration.proto \
|
||||
google/protobuf/empty.proto \
|
||||
google/protobuf/field_mask.proto \
|
||||
google/protobuf/source_context.proto \
|
||||
google/protobuf/struct.proto \
|
||||
google/protobuf/timestamp.proto \
|
||||
google/protobuf/type.proto \
|
||||
google/protobuf/wrappers.proto
|
||||
|
||||
# Not sure why these don't get cleaned automatically.
|
||||
clean-local:
|
||||
rm -f *.loT
|
||||
|
||||
CLEANFILES = $(protoc_outputs) unittest_proto_middleman \
|
||||
testzip.jar testzip.list testzip.proto testzip.zip \
|
||||
no_warning_test.cc
|
||||
|
||||
MAINTAINERCLEANFILES = \
|
||||
Makefile.in
|
||||
|
||||
nobase_include_HEADERS = \
|
||||
google/protobuf/any.h \
|
||||
google/protobuf/any.pb.h \
|
||||
google/protobuf/api.pb.h \
|
||||
google/protobuf/arena.h \
|
||||
google/protobuf/arena_impl.h \
|
||||
google/protobuf/arenastring.h \
|
||||
google/protobuf/arenaz_sampler.h \
|
||||
google/protobuf/compiler/code_generator.h \
|
||||
google/protobuf/compiler/command_line_interface.h \
|
||||
google/protobuf/compiler/cpp/cpp_generator.h \
|
||||
google/protobuf/compiler/cpp/file.h \
|
||||
google/protobuf/compiler/cpp/generator.h \
|
||||
google/protobuf/compiler/cpp/helpers.h \
|
||||
google/protobuf/compiler/cpp/names.h \
|
||||
google/protobuf/compiler/csharp/csharp_doc_comment.h \
|
||||
google/protobuf/compiler/csharp/csharp_generator.h \
|
||||
google/protobuf/compiler/csharp/csharp_names.h \
|
||||
google/protobuf/compiler/csharp/csharp_options.h \
|
||||
google/protobuf/compiler/importer.h \
|
||||
google/protobuf/compiler/java/generator.h \
|
||||
google/protobuf/compiler/java/java_generator.h \
|
||||
google/protobuf/compiler/java/kotlin_generator.h \
|
||||
google/protobuf/compiler/java/names.h \
|
||||
google/protobuf/compiler/objectivec/objectivec_generator.h \
|
||||
google/protobuf/compiler/objectivec/objectivec_helpers.h \
|
||||
google/protobuf/compiler/parser.h \
|
||||
google/protobuf/compiler/php/php_generator.h \
|
||||
google/protobuf/compiler/plugin.h \
|
||||
google/protobuf/compiler/plugin.pb.h \
|
||||
google/protobuf/compiler/python/generator.h \
|
||||
google/protobuf/compiler/python/pyi_generator.h \
|
||||
google/protobuf/compiler/python/python_generator.h \
|
||||
google/protobuf/compiler/ruby/ruby_generator.h \
|
||||
google/protobuf/descriptor.h \
|
||||
google/protobuf/descriptor.pb.h \
|
||||
google/protobuf/descriptor_database.h \
|
||||
google/protobuf/duration.pb.h \
|
||||
google/protobuf/dynamic_message.h \
|
||||
google/protobuf/empty.pb.h \
|
||||
google/protobuf/endian.h \
|
||||
google/protobuf/explicitly_constructed.h \
|
||||
google/protobuf/extension_set.h \
|
||||
google/protobuf/extension_set_inl.h \
|
||||
google/protobuf/field_access_listener.h \
|
||||
google/protobuf/field_mask.pb.h \
|
||||
google/protobuf/generated_enum_reflection.h \
|
||||
google/protobuf/generated_enum_util.h \
|
||||
google/protobuf/generated_message_bases.h \
|
||||
google/protobuf/generated_message_reflection.h \
|
||||
google/protobuf/generated_message_tctable_decl.h \
|
||||
google/protobuf/generated_message_tctable_impl.h \
|
||||
google/protobuf/generated_message_util.h \
|
||||
google/protobuf/has_bits.h \
|
||||
google/protobuf/implicit_weak_message.h \
|
||||
google/protobuf/inlined_string_field.h \
|
||||
google/protobuf/io/coded_stream.h \
|
||||
$(GZHEADERS) \
|
||||
google/protobuf/io/io_win32.h \
|
||||
google/protobuf/io/printer.h \
|
||||
google/protobuf/io/strtod.h \
|
||||
google/protobuf/io/tokenizer.h \
|
||||
google/protobuf/io/zero_copy_stream.h \
|
||||
google/protobuf/io/zero_copy_stream_impl.h \
|
||||
google/protobuf/io/zero_copy_stream_impl_lite.h \
|
||||
google/protobuf/map.h \
|
||||
google/protobuf/map_entry.h \
|
||||
google/protobuf/map_entry_lite.h \
|
||||
google/protobuf/map_field.h \
|
||||
google/protobuf/map_field_inl.h \
|
||||
google/protobuf/map_field_lite.h \
|
||||
google/protobuf/map_type_handler.h \
|
||||
google/protobuf/message.h \
|
||||
google/protobuf/message_lite.h \
|
||||
google/protobuf/metadata.h \
|
||||
google/protobuf/metadata_lite.h \
|
||||
google/protobuf/parse_context.h \
|
||||
google/protobuf/port.h \
|
||||
google/protobuf/port_def.inc \
|
||||
google/protobuf/port_undef.inc \
|
||||
google/protobuf/reflection.h \
|
||||
google/protobuf/reflection_internal.h \
|
||||
google/protobuf/reflection_ops.h \
|
||||
google/protobuf/repeated_field.h \
|
||||
google/protobuf/repeated_ptr_field.h \
|
||||
google/protobuf/service.h \
|
||||
google/protobuf/source_context.pb.h \
|
||||
google/protobuf/struct.pb.h \
|
||||
google/protobuf/stubs/bytestream.h \
|
||||
google/protobuf/stubs/callback.h \
|
||||
google/protobuf/stubs/casts.h \
|
||||
google/protobuf/stubs/common.h \
|
||||
google/protobuf/stubs/hash.h \
|
||||
google/protobuf/stubs/logging.h \
|
||||
google/protobuf/stubs/macros.h \
|
||||
google/protobuf/stubs/map_util.h \
|
||||
google/protobuf/stubs/mutex.h \
|
||||
google/protobuf/stubs/once.h \
|
||||
google/protobuf/stubs/platform_macros.h \
|
||||
google/protobuf/stubs/port.h \
|
||||
google/protobuf/stubs/status.h \
|
||||
google/protobuf/stubs/stl_util.h \
|
||||
google/protobuf/stubs/stringpiece.h \
|
||||
google/protobuf/stubs/strutil.h \
|
||||
google/protobuf/stubs/template_util.h \
|
||||
google/protobuf/text_format.h \
|
||||
google/protobuf/timestamp.pb.h \
|
||||
google/protobuf/type.pb.h \
|
||||
google/protobuf/unknown_field_set.h \
|
||||
google/protobuf/util/delimited_message_util.h \
|
||||
google/protobuf/util/field_comparator.h \
|
||||
google/protobuf/util/field_mask_util.h \
|
||||
google/protobuf/util/json_util.h \
|
||||
google/protobuf/util/message_differencer.h \
|
||||
google/protobuf/util/time_util.h \
|
||||
google/protobuf/util/type_resolver.h \
|
||||
google/protobuf/util/type_resolver_util.h \
|
||||
google/protobuf/wire_format.h \
|
||||
google/protobuf/wire_format_lite.h \
|
||||
google/protobuf/wrappers.pb.h
|
||||
|
||||
lib_LTLIBRARIES = libprotobuf-lite.la libprotobuf.la libprotoc.la
|
||||
|
||||
libprotobuf_lite_la_LIBADD = $(PTHREAD_LIBS) $(LIBATOMIC_LIBS)
|
||||
libprotobuf_lite_la_LDFLAGS = -version-info $(PROTOBUF_VERSION) -export-dynamic -no-undefined
|
||||
if HAVE_LD_VERSION_SCRIPT
|
||||
libprotobuf_lite_la_LDFLAGS += -Wl,--version-script=$(srcdir)/libprotobuf-lite.map
|
||||
EXTRA_libprotobuf_lite_la_DEPENDENCIES = libprotobuf-lite.map
|
||||
endif
|
||||
libprotobuf_lite_la_SOURCES = \
|
||||
google/protobuf/any_lite.cc \
|
||||
google/protobuf/arena.cc \
|
||||
google/protobuf/arenastring.cc \
|
||||
google/protobuf/arenaz_sampler.cc \
|
||||
google/protobuf/extension_set.cc \
|
||||
google/protobuf/generated_enum_util.cc \
|
||||
google/protobuf/generated_message_tctable_lite.cc \
|
||||
google/protobuf/generated_message_util.cc \
|
||||
google/protobuf/implicit_weak_message.cc \
|
||||
google/protobuf/inlined_string_field.cc \
|
||||
google/protobuf/io/coded_stream.cc \
|
||||
google/protobuf/io/io_win32.cc \
|
||||
google/protobuf/io/strtod.cc \
|
||||
google/protobuf/io/zero_copy_stream.cc \
|
||||
google/protobuf/io/zero_copy_stream_impl.cc \
|
||||
google/protobuf/io/zero_copy_stream_impl_lite.cc \
|
||||
google/protobuf/map.cc \
|
||||
google/protobuf/message_lite.cc \
|
||||
google/protobuf/parse_context.cc \
|
||||
google/protobuf/repeated_field.cc \
|
||||
google/protobuf/repeated_ptr_field.cc \
|
||||
google/protobuf/string_member_robber.h \
|
||||
google/protobuf/stubs/bytestream.cc \
|
||||
google/protobuf/stubs/common.cc \
|
||||
google/protobuf/stubs/int128.cc \
|
||||
google/protobuf/stubs/int128.h \
|
||||
google/protobuf/stubs/mathutil.h \
|
||||
google/protobuf/stubs/status.cc \
|
||||
google/protobuf/stubs/status_macros.h \
|
||||
google/protobuf/stubs/statusor.cc \
|
||||
google/protobuf/stubs/statusor.h \
|
||||
google/protobuf/stubs/stringpiece.cc \
|
||||
google/protobuf/stubs/stringprintf.cc \
|
||||
google/protobuf/stubs/stringprintf.h \
|
||||
google/protobuf/stubs/structurally_valid.cc \
|
||||
google/protobuf/stubs/strutil.cc \
|
||||
google/protobuf/stubs/time.cc \
|
||||
google/protobuf/stubs/time.h \
|
||||
google/protobuf/wire_format_lite.cc
|
||||
|
||||
libprotobuf_la_LIBADD = $(PTHREAD_LIBS) $(LIBATOMIC_LIBS)
|
||||
libprotobuf_la_LDFLAGS = -version-info $(PROTOBUF_VERSION) -export-dynamic -no-undefined
|
||||
if HAVE_LD_VERSION_SCRIPT
|
||||
libprotobuf_la_LDFLAGS += -Wl,--version-script=$(srcdir)/libprotobuf.map
|
||||
EXTRA_libprotobuf_la_DEPENDENCIES = libprotobuf.map
|
||||
endif
|
||||
libprotobuf_la_SOURCES = \
|
||||
$(libprotobuf_lite_la_SOURCES) \
|
||||
google/protobuf/any.cc \
|
||||
google/protobuf/any.pb.cc \
|
||||
google/protobuf/api.pb.cc \
|
||||
google/protobuf/compiler/importer.cc \
|
||||
google/protobuf/compiler/parser.cc \
|
||||
google/protobuf/descriptor.cc \
|
||||
google/protobuf/descriptor.pb.cc \
|
||||
google/protobuf/descriptor_database.cc \
|
||||
google/protobuf/duration.pb.cc \
|
||||
google/protobuf/dynamic_message.cc \
|
||||
google/protobuf/empty.pb.cc \
|
||||
google/protobuf/extension_set_heavy.cc \
|
||||
google/protobuf/field_mask.pb.cc \
|
||||
google/protobuf/generated_message_bases.cc \
|
||||
google/protobuf/generated_message_reflection.cc \
|
||||
google/protobuf/generated_message_tctable_full.cc \
|
||||
google/protobuf/io/gzip_stream.cc \
|
||||
google/protobuf/io/printer.cc \
|
||||
google/protobuf/io/tokenizer.cc \
|
||||
google/protobuf/map_field.cc \
|
||||
google/protobuf/message.cc \
|
||||
google/protobuf/reflection_ops.cc \
|
||||
google/protobuf/service.cc \
|
||||
google/protobuf/source_context.pb.cc \
|
||||
google/protobuf/struct.pb.cc \
|
||||
google/protobuf/stubs/substitute.cc \
|
||||
google/protobuf/stubs/substitute.h \
|
||||
google/protobuf/text_format.cc \
|
||||
google/protobuf/timestamp.pb.cc \
|
||||
google/protobuf/type.pb.cc \
|
||||
google/protobuf/unknown_field_set.cc \
|
||||
google/protobuf/util/delimited_message_util.cc \
|
||||
google/protobuf/util/field_comparator.cc \
|
||||
google/protobuf/util/field_mask_util.cc \
|
||||
google/protobuf/util/internal/constants.h \
|
||||
google/protobuf/util/internal/datapiece.cc \
|
||||
google/protobuf/util/internal/datapiece.h \
|
||||
google/protobuf/util/internal/default_value_objectwriter.cc \
|
||||
google/protobuf/util/internal/default_value_objectwriter.h \
|
||||
google/protobuf/util/internal/error_listener.cc \
|
||||
google/protobuf/util/internal/error_listener.h \
|
||||
google/protobuf/util/internal/expecting_objectwriter.h \
|
||||
google/protobuf/util/internal/field_mask_utility.cc \
|
||||
google/protobuf/util/internal/field_mask_utility.h \
|
||||
google/protobuf/util/internal/json_escaping.cc \
|
||||
google/protobuf/util/internal/json_escaping.h \
|
||||
google/protobuf/util/internal/json_objectwriter.cc \
|
||||
google/protobuf/util/internal/json_objectwriter.h \
|
||||
google/protobuf/util/internal/json_stream_parser.cc \
|
||||
google/protobuf/util/internal/json_stream_parser.h \
|
||||
google/protobuf/util/internal/location_tracker.h \
|
||||
google/protobuf/util/internal/mock_error_listener.h \
|
||||
google/protobuf/util/internal/object_location_tracker.h \
|
||||
google/protobuf/util/internal/object_source.h \
|
||||
google/protobuf/util/internal/object_writer.cc \
|
||||
google/protobuf/util/internal/object_writer.h \
|
||||
google/protobuf/util/internal/proto_writer.cc \
|
||||
google/protobuf/util/internal/proto_writer.h \
|
||||
google/protobuf/util/internal/protostream_objectsource.cc \
|
||||
google/protobuf/util/internal/protostream_objectsource.h \
|
||||
google/protobuf/util/internal/protostream_objectwriter.cc \
|
||||
google/protobuf/util/internal/protostream_objectwriter.h \
|
||||
google/protobuf/util/internal/structured_objectwriter.h \
|
||||
google/protobuf/util/internal/type_info.cc \
|
||||
google/protobuf/util/internal/type_info.h \
|
||||
google/protobuf/util/internal/type_info_test_helper.h \
|
||||
google/protobuf/util/internal/utility.cc \
|
||||
google/protobuf/util/internal/utility.h \
|
||||
google/protobuf/util/json_util.cc \
|
||||
google/protobuf/util/message_differencer.cc \
|
||||
google/protobuf/util/time_util.cc \
|
||||
google/protobuf/util/type_resolver_util.cc \
|
||||
google/protobuf/wire_format.cc \
|
||||
google/protobuf/wrappers.pb.cc
|
||||
|
||||
nodist_libprotobuf_la_SOURCES = $(nodist_libprotobuf_lite_la_SOURCES)
|
||||
|
||||
libprotoc_la_LIBADD = $(PTHREAD_LIBS) libprotobuf.la
|
||||
libprotoc_la_LDFLAGS = -version-info $(PROTOBUF_VERSION) -export-dynamic -no-undefined
|
||||
if HAVE_LD_VERSION_SCRIPT
|
||||
libprotoc_la_LDFLAGS += -Wl,--version-script=$(srcdir)/libprotoc.map
|
||||
EXTRA_libprotoc_la_DEPENDENCIES = libprotoc.map
|
||||
endif
|
||||
libprotoc_la_SOURCES = \
|
||||
google/protobuf/compiler/code_generator.cc \
|
||||
google/protobuf/compiler/command_line_interface.cc \
|
||||
google/protobuf/compiler/cpp/enum.cc \
|
||||
google/protobuf/compiler/cpp/enum.h \
|
||||
google/protobuf/compiler/cpp/enum_field.cc \
|
||||
google/protobuf/compiler/cpp/enum_field.h \
|
||||
google/protobuf/compiler/cpp/extension.cc \
|
||||
google/protobuf/compiler/cpp/extension.h \
|
||||
google/protobuf/compiler/cpp/field.cc \
|
||||
google/protobuf/compiler/cpp/field.h \
|
||||
google/protobuf/compiler/cpp/file.cc \
|
||||
google/protobuf/compiler/cpp/generator.cc \
|
||||
google/protobuf/compiler/cpp/helpers.cc \
|
||||
google/protobuf/compiler/cpp/map_field.cc \
|
||||
google/protobuf/compiler/cpp/map_field.h \
|
||||
google/protobuf/compiler/cpp/message.cc \
|
||||
google/protobuf/compiler/cpp/message.h \
|
||||
google/protobuf/compiler/cpp/message_field.cc \
|
||||
google/protobuf/compiler/cpp/message_field.h \
|
||||
google/protobuf/compiler/cpp/message_layout_helper.h \
|
||||
google/protobuf/compiler/cpp/options.h \
|
||||
google/protobuf/compiler/cpp/padding_optimizer.cc \
|
||||
google/protobuf/compiler/cpp/padding_optimizer.h \
|
||||
google/protobuf/compiler/cpp/parse_function_generator.cc \
|
||||
google/protobuf/compiler/cpp/parse_function_generator.h \
|
||||
google/protobuf/compiler/cpp/primitive_field.cc \
|
||||
google/protobuf/compiler/cpp/primitive_field.h \
|
||||
google/protobuf/compiler/cpp/service.cc \
|
||||
google/protobuf/compiler/cpp/service.h \
|
||||
google/protobuf/compiler/cpp/string_field.cc \
|
||||
google/protobuf/compiler/cpp/string_field.h \
|
||||
google/protobuf/compiler/csharp/csharp_doc_comment.cc \
|
||||
google/protobuf/compiler/csharp/csharp_enum.cc \
|
||||
google/protobuf/compiler/csharp/csharp_enum.h \
|
||||
google/protobuf/compiler/csharp/csharp_enum_field.cc \
|
||||
google/protobuf/compiler/csharp/csharp_enum_field.h \
|
||||
google/protobuf/compiler/csharp/csharp_field_base.cc \
|
||||
google/protobuf/compiler/csharp/csharp_field_base.h \
|
||||
google/protobuf/compiler/csharp/csharp_generator.cc \
|
||||
google/protobuf/compiler/csharp/csharp_helpers.cc \
|
||||
google/protobuf/compiler/csharp/csharp_helpers.h \
|
||||
google/protobuf/compiler/csharp/csharp_map_field.cc \
|
||||
google/protobuf/compiler/csharp/csharp_map_field.h \
|
||||
google/protobuf/compiler/csharp/csharp_message.cc \
|
||||
google/protobuf/compiler/csharp/csharp_message.h \
|
||||
google/protobuf/compiler/csharp/csharp_message_field.cc \
|
||||
google/protobuf/compiler/csharp/csharp_message_field.h \
|
||||
google/protobuf/compiler/csharp/csharp_primitive_field.cc \
|
||||
google/protobuf/compiler/csharp/csharp_primitive_field.h \
|
||||
google/protobuf/compiler/csharp/csharp_reflection_class.cc \
|
||||
google/protobuf/compiler/csharp/csharp_reflection_class.h \
|
||||
google/protobuf/compiler/csharp/csharp_repeated_enum_field.cc \
|
||||
google/protobuf/compiler/csharp/csharp_repeated_enum_field.h \
|
||||
google/protobuf/compiler/csharp/csharp_repeated_message_field.cc \
|
||||
google/protobuf/compiler/csharp/csharp_repeated_message_field.h \
|
||||
google/protobuf/compiler/csharp/csharp_repeated_primitive_field.cc \
|
||||
google/protobuf/compiler/csharp/csharp_repeated_primitive_field.h \
|
||||
google/protobuf/compiler/csharp/csharp_source_generator_base.cc \
|
||||
google/protobuf/compiler/csharp/csharp_source_generator_base.h \
|
||||
google/protobuf/compiler/csharp/csharp_wrapper_field.cc \
|
||||
google/protobuf/compiler/csharp/csharp_wrapper_field.h \
|
||||
google/protobuf/compiler/java/context.cc \
|
||||
google/protobuf/compiler/java/context.h \
|
||||
google/protobuf/compiler/java/doc_comment.cc \
|
||||
google/protobuf/compiler/java/doc_comment.h \
|
||||
google/protobuf/compiler/java/enum.cc \
|
||||
google/protobuf/compiler/java/enum.h \
|
||||
google/protobuf/compiler/java/enum_field.cc \
|
||||
google/protobuf/compiler/java/enum_field.h \
|
||||
google/protobuf/compiler/java/enum_field_lite.cc \
|
||||
google/protobuf/compiler/java/enum_field_lite.h \
|
||||
google/protobuf/compiler/java/enum_lite.cc \
|
||||
google/protobuf/compiler/java/enum_lite.h \
|
||||
google/protobuf/compiler/java/extension.cc \
|
||||
google/protobuf/compiler/java/extension.h \
|
||||
google/protobuf/compiler/java/extension_lite.cc \
|
||||
google/protobuf/compiler/java/extension_lite.h \
|
||||
google/protobuf/compiler/java/field.cc \
|
||||
google/protobuf/compiler/java/field.h \
|
||||
google/protobuf/compiler/java/file.cc \
|
||||
google/protobuf/compiler/java/file.h \
|
||||
google/protobuf/compiler/java/generator.cc \
|
||||
google/protobuf/compiler/java/generator_factory.cc \
|
||||
google/protobuf/compiler/java/generator_factory.h \
|
||||
google/protobuf/compiler/java/helpers.cc \
|
||||
google/protobuf/compiler/java/helpers.h \
|
||||
google/protobuf/compiler/java/kotlin_generator.cc \
|
||||
google/protobuf/compiler/java/map_field.cc \
|
||||
google/protobuf/compiler/java/map_field.h \
|
||||
google/protobuf/compiler/java/map_field_lite.cc \
|
||||
google/protobuf/compiler/java/map_field_lite.h \
|
||||
google/protobuf/compiler/java/message.cc \
|
||||
google/protobuf/compiler/java/message.h \
|
||||
google/protobuf/compiler/java/message_builder.cc \
|
||||
google/protobuf/compiler/java/message_builder.h \
|
||||
google/protobuf/compiler/java/message_builder_lite.cc \
|
||||
google/protobuf/compiler/java/message_builder_lite.h \
|
||||
google/protobuf/compiler/java/message_field.cc \
|
||||
google/protobuf/compiler/java/message_field.h \
|
||||
google/protobuf/compiler/java/message_field_lite.cc \
|
||||
google/protobuf/compiler/java/message_field_lite.h \
|
||||
google/protobuf/compiler/java/message_lite.cc \
|
||||
google/protobuf/compiler/java/message_lite.h \
|
||||
google/protobuf/compiler/java/name_resolver.cc \
|
||||
google/protobuf/compiler/java/name_resolver.h \
|
||||
google/protobuf/compiler/java/options.h \
|
||||
google/protobuf/compiler/java/primitive_field.cc \
|
||||
google/protobuf/compiler/java/primitive_field.h \
|
||||
google/protobuf/compiler/java/primitive_field_lite.cc \
|
||||
google/protobuf/compiler/java/primitive_field_lite.h \
|
||||
google/protobuf/compiler/java/service.cc \
|
||||
google/protobuf/compiler/java/service.h \
|
||||
google/protobuf/compiler/java/shared_code_generator.cc \
|
||||
google/protobuf/compiler/java/shared_code_generator.h \
|
||||
google/protobuf/compiler/java/string_field.cc \
|
||||
google/protobuf/compiler/java/string_field.h \
|
||||
google/protobuf/compiler/java/string_field_lite.cc \
|
||||
google/protobuf/compiler/java/string_field_lite.h \
|
||||
google/protobuf/compiler/objectivec/objectivec_enum.cc \
|
||||
google/protobuf/compiler/objectivec/objectivec_enum.h \
|
||||
google/protobuf/compiler/objectivec/objectivec_enum_field.cc \
|
||||
google/protobuf/compiler/objectivec/objectivec_enum_field.h \
|
||||
google/protobuf/compiler/objectivec/objectivec_extension.cc \
|
||||
google/protobuf/compiler/objectivec/objectivec_extension.h \
|
||||
google/protobuf/compiler/objectivec/objectivec_field.cc \
|
||||
google/protobuf/compiler/objectivec/objectivec_field.h \
|
||||
google/protobuf/compiler/objectivec/objectivec_file.cc \
|
||||
google/protobuf/compiler/objectivec/objectivec_file.h \
|
||||
google/protobuf/compiler/objectivec/objectivec_generator.cc \
|
||||
google/protobuf/compiler/objectivec/objectivec_helpers.cc \
|
||||
google/protobuf/compiler/objectivec/objectivec_map_field.cc \
|
||||
google/protobuf/compiler/objectivec/objectivec_map_field.h \
|
||||
google/protobuf/compiler/objectivec/objectivec_message.cc \
|
||||
google/protobuf/compiler/objectivec/objectivec_message.h \
|
||||
google/protobuf/compiler/objectivec/objectivec_message_field.cc \
|
||||
google/protobuf/compiler/objectivec/objectivec_message_field.h \
|
||||
google/protobuf/compiler/objectivec/objectivec_nsobject_methods.h \
|
||||
google/protobuf/compiler/objectivec/objectivec_oneof.cc \
|
||||
google/protobuf/compiler/objectivec/objectivec_oneof.h \
|
||||
google/protobuf/compiler/objectivec/objectivec_primitive_field.cc \
|
||||
google/protobuf/compiler/objectivec/objectivec_primitive_field.h \
|
||||
google/protobuf/compiler/php/php_generator.cc \
|
||||
google/protobuf/compiler/plugin.cc \
|
||||
google/protobuf/compiler/plugin.pb.cc \
|
||||
google/protobuf/compiler/python/generator.cc \
|
||||
google/protobuf/compiler/python/helpers.cc \
|
||||
google/protobuf/compiler/python/helpers.h \
|
||||
google/protobuf/compiler/python/pyi_generator.cc \
|
||||
google/protobuf/compiler/ruby/ruby_generator.cc \
|
||||
google/protobuf/compiler/scc.h \
|
||||
google/protobuf/compiler/subprocess.cc \
|
||||
google/protobuf/compiler/subprocess.h \
|
||||
google/protobuf/compiler/zip_writer.cc \
|
||||
google/protobuf/compiler/zip_writer.h
|
||||
|
||||
bin_PROGRAMS = protoc
|
||||
protoc_LDADD = $(PTHREAD_LIBS) libprotobuf.la libprotoc.la
|
||||
protoc_SOURCES = google/protobuf/compiler/main.cc
|
||||
|
||||
# Tests ==============================================================
|
||||
|
||||
protoc_inputs = \
|
||||
google/protobuf/any_test.proto \
|
||||
google/protobuf/compiler/cpp/test_bad_identifiers.proto \
|
||||
google/protobuf/compiler/cpp/test_large_enum_value.proto \
|
||||
google/protobuf/map_lite_unittest.proto \
|
||||
google/protobuf/map_proto2_unittest.proto \
|
||||
google/protobuf/map_unittest.proto \
|
||||
google/protobuf/unittest.proto \
|
||||
google/protobuf/unittest_arena.proto \
|
||||
google/protobuf/unittest_custom_options.proto \
|
||||
google/protobuf/unittest_drop_unknown_fields.proto \
|
||||
google/protobuf/unittest_embed_optimize_for.proto \
|
||||
google/protobuf/unittest_empty.proto \
|
||||
google/protobuf/unittest_enormous_descriptor.proto \
|
||||
google/protobuf/unittest_import.proto \
|
||||
google/protobuf/unittest_import_lite.proto \
|
||||
google/protobuf/unittest_import_public.proto \
|
||||
google/protobuf/unittest_import_public_lite.proto \
|
||||
google/protobuf/unittest_lazy_dependencies.proto \
|
||||
google/protobuf/unittest_lazy_dependencies_custom_option.proto \
|
||||
google/protobuf/unittest_lazy_dependencies_enum.proto \
|
||||
google/protobuf/unittest_lite.proto \
|
||||
google/protobuf/unittest_lite_imports_nonlite.proto \
|
||||
google/protobuf/unittest_mset.proto \
|
||||
google/protobuf/unittest_mset_wire_format.proto \
|
||||
google/protobuf/unittest_no_field_presence.proto \
|
||||
google/protobuf/unittest_no_generic_services.proto \
|
||||
google/protobuf/unittest_optimize_for.proto \
|
||||
google/protobuf/unittest_preserve_unknown_enum.proto \
|
||||
google/protobuf/unittest_preserve_unknown_enum2.proto \
|
||||
google/protobuf/unittest_proto3.proto \
|
||||
google/protobuf/unittest_proto3_arena.proto \
|
||||
google/protobuf/unittest_proto3_arena_lite.proto \
|
||||
google/protobuf/unittest_proto3_lite.proto \
|
||||
google/protobuf/unittest_proto3_optional.proto \
|
||||
google/protobuf/unittest_well_known_types.proto \
|
||||
google/protobuf/util/internal/testdata/anys.proto \
|
||||
google/protobuf/util/internal/testdata/books.proto \
|
||||
google/protobuf/util/internal/testdata/default_value.proto \
|
||||
google/protobuf/util/internal/testdata/default_value_test.proto \
|
||||
google/protobuf/util/internal/testdata/field_mask.proto \
|
||||
google/protobuf/util/internal/testdata/maps.proto \
|
||||
google/protobuf/util/internal/testdata/oneofs.proto \
|
||||
google/protobuf/util/internal/testdata/proto3.proto \
|
||||
google/protobuf/util/internal/testdata/struct.proto \
|
||||
google/protobuf/util/internal/testdata/timestamp_duration.proto \
|
||||
google/protobuf/util/internal/testdata/wrappers.proto \
|
||||
google/protobuf/util/json_format.proto \
|
||||
google/protobuf/util/json_format_proto3.proto \
|
||||
google/protobuf/util/message_differencer_unittest.proto
|
||||
|
||||
EXTRA_DIST = \
|
||||
$(protoc_inputs) \
|
||||
README.md \
|
||||
google/protobuf/compiler/package_info.h \
|
||||
google/protobuf/compiler/ruby/ruby_generated_code.proto \
|
||||
google/protobuf/compiler/ruby/ruby_generated_code_pb.rb \
|
||||
google/protobuf/compiler/ruby/ruby_generated_code_proto2.proto \
|
||||
google/protobuf/compiler/ruby/ruby_generated_code_proto2_import.proto \
|
||||
google/protobuf/compiler/ruby/ruby_generated_code_proto2_pb.rb \
|
||||
google/protobuf/compiler/ruby/ruby_generated_pkg_explicit.proto \
|
||||
google/protobuf/compiler/ruby/ruby_generated_pkg_explicit_legacy.proto \
|
||||
google/protobuf/compiler/ruby/ruby_generated_pkg_explicit_legacy_pb.rb \
|
||||
google/protobuf/compiler/ruby/ruby_generated_pkg_explicit_pb.rb \
|
||||
google/protobuf/compiler/ruby/ruby_generated_pkg_implicit.proto \
|
||||
google/protobuf/compiler/ruby/ruby_generated_pkg_implicit_pb.rb \
|
||||
google/protobuf/compiler/zip_output_unittest.sh \
|
||||
google/protobuf/io/gzip_stream.h \
|
||||
google/protobuf/io/gzip_stream_unittest.sh \
|
||||
google/protobuf/io/package_info.h \
|
||||
google/protobuf/package_info.h \
|
||||
google/protobuf/test_messages_proto2.proto \
|
||||
google/protobuf/test_messages_proto3.proto \
|
||||
google/protobuf/testdata/bad_utf8_string \
|
||||
google/protobuf/testdata/golden_message \
|
||||
google/protobuf/testdata/golden_message_maps \
|
||||
google/protobuf/testdata/golden_message_oneof_implemented \
|
||||
google/protobuf/testdata/golden_message_proto3 \
|
||||
google/protobuf/testdata/golden_packed_fields_message \
|
||||
google/protobuf/testdata/map_test_data.txt \
|
||||
google/protobuf/testdata/text_format_unittest_data.txt \
|
||||
google/protobuf/testdata/text_format_unittest_data_oneof_implemented.txt \
|
||||
google/protobuf/testdata/text_format_unittest_data_pointy.txt \
|
||||
google/protobuf/testdata/text_format_unittest_data_pointy_oneof.txt \
|
||||
google/protobuf/testdata/text_format_unittest_extensions_data.txt \
|
||||
google/protobuf/testdata/text_format_unittest_extensions_data_pointy.txt \
|
||||
google/protobuf/util/package_info.h \
|
||||
libprotobuf-lite.map \
|
||||
libprotobuf.map \
|
||||
libprotoc.map \
|
||||
solaris/libstdc++.la
|
||||
|
||||
protoc_lite_outputs = \
|
||||
google/protobuf/map_lite_unittest.pb.cc \
|
||||
google/protobuf/map_lite_unittest.pb.h \
|
||||
google/protobuf/unittest_import_lite.pb.cc \
|
||||
google/protobuf/unittest_import_lite.pb.h \
|
||||
google/protobuf/unittest_import_public_lite.pb.cc \
|
||||
google/protobuf/unittest_import_public_lite.pb.h \
|
||||
google/protobuf/unittest_lite.pb.cc \
|
||||
google/protobuf/unittest_lite.pb.h
|
||||
|
||||
protoc_outputs = \
|
||||
$(protoc_lite_outputs) \
|
||||
google/protobuf/any_test.pb.cc \
|
||||
google/protobuf/any_test.pb.h \
|
||||
google/protobuf/compiler/cpp/test_bad_identifiers.pb.cc \
|
||||
google/protobuf/compiler/cpp/test_bad_identifiers.pb.h \
|
||||
google/protobuf/compiler/cpp/test_large_enum_value.pb.cc \
|
||||
google/protobuf/compiler/cpp/test_large_enum_value.pb.h \
|
||||
google/protobuf/map_proto2_unittest.pb.cc \
|
||||
google/protobuf/map_proto2_unittest.pb.h \
|
||||
google/protobuf/map_unittest.pb.cc \
|
||||
google/protobuf/map_unittest.pb.h \
|
||||
google/protobuf/unittest.pb.cc \
|
||||
google/protobuf/unittest.pb.h \
|
||||
google/protobuf/unittest_arena.pb.cc \
|
||||
google/protobuf/unittest_arena.pb.h \
|
||||
google/protobuf/unittest_custom_options.pb.cc \
|
||||
google/protobuf/unittest_custom_options.pb.h \
|
||||
google/protobuf/unittest_drop_unknown_fields.pb.cc \
|
||||
google/protobuf/unittest_drop_unknown_fields.pb.h \
|
||||
google/protobuf/unittest_embed_optimize_for.pb.cc \
|
||||
google/protobuf/unittest_embed_optimize_for.pb.h \
|
||||
google/protobuf/unittest_empty.pb.cc \
|
||||
google/protobuf/unittest_empty.pb.h \
|
||||
google/protobuf/unittest_enormous_descriptor.pb.cc \
|
||||
google/protobuf/unittest_enormous_descriptor.pb.h \
|
||||
google/protobuf/unittest_import.pb.cc \
|
||||
google/protobuf/unittest_import.pb.h \
|
||||
google/protobuf/unittest_import_public.pb.cc \
|
||||
google/protobuf/unittest_import_public.pb.h \
|
||||
google/protobuf/unittest_lazy_dependencies.pb.cc \
|
||||
google/protobuf/unittest_lazy_dependencies.pb.h \
|
||||
google/protobuf/unittest_lazy_dependencies_custom_option.pb.cc \
|
||||
google/protobuf/unittest_lazy_dependencies_custom_option.pb.h \
|
||||
google/protobuf/unittest_lazy_dependencies_enum.pb.cc \
|
||||
google/protobuf/unittest_lazy_dependencies_enum.pb.h \
|
||||
google/protobuf/unittest_lite_imports_nonlite.pb.cc \
|
||||
google/protobuf/unittest_lite_imports_nonlite.pb.h \
|
||||
google/protobuf/unittest_mset.pb.cc \
|
||||
google/protobuf/unittest_mset.pb.h \
|
||||
google/protobuf/unittest_mset_wire_format.pb.cc \
|
||||
google/protobuf/unittest_mset_wire_format.pb.h \
|
||||
google/protobuf/unittest_no_field_presence.pb.cc \
|
||||
google/protobuf/unittest_no_field_presence.pb.h \
|
||||
google/protobuf/unittest_no_generic_services.pb.cc \
|
||||
google/protobuf/unittest_no_generic_services.pb.h \
|
||||
google/protobuf/unittest_optimize_for.pb.cc \
|
||||
google/protobuf/unittest_optimize_for.pb.h \
|
||||
google/protobuf/unittest_preserve_unknown_enum.pb.cc \
|
||||
google/protobuf/unittest_preserve_unknown_enum.pb.h \
|
||||
google/protobuf/unittest_preserve_unknown_enum2.pb.cc \
|
||||
google/protobuf/unittest_preserve_unknown_enum2.pb.h \
|
||||
google/protobuf/unittest_proto3.pb.cc \
|
||||
google/protobuf/unittest_proto3.pb.h \
|
||||
google/protobuf/unittest_proto3_arena.pb.cc \
|
||||
google/protobuf/unittest_proto3_arena.pb.h \
|
||||
google/protobuf/unittest_proto3_arena_lite.pb.cc \
|
||||
google/protobuf/unittest_proto3_arena_lite.pb.h \
|
||||
google/protobuf/unittest_proto3_lite.pb.cc \
|
||||
google/protobuf/unittest_proto3_lite.pb.h \
|
||||
google/protobuf/unittest_proto3_optional.pb.cc \
|
||||
google/protobuf/unittest_proto3_optional.pb.h \
|
||||
google/protobuf/unittest_well_known_types.pb.cc \
|
||||
google/protobuf/unittest_well_known_types.pb.h \
|
||||
google/protobuf/util/internal/testdata/anys.pb.cc \
|
||||
google/protobuf/util/internal/testdata/anys.pb.h \
|
||||
google/protobuf/util/internal/testdata/books.pb.cc \
|
||||
google/protobuf/util/internal/testdata/books.pb.h \
|
||||
google/protobuf/util/internal/testdata/default_value.pb.cc \
|
||||
google/protobuf/util/internal/testdata/default_value.pb.h \
|
||||
google/protobuf/util/internal/testdata/default_value_test.pb.cc \
|
||||
google/protobuf/util/internal/testdata/default_value_test.pb.h \
|
||||
google/protobuf/util/internal/testdata/field_mask.pb.cc \
|
||||
google/protobuf/util/internal/testdata/field_mask.pb.h \
|
||||
google/protobuf/util/internal/testdata/maps.pb.cc \
|
||||
google/protobuf/util/internal/testdata/maps.pb.h \
|
||||
google/protobuf/util/internal/testdata/oneofs.pb.cc \
|
||||
google/protobuf/util/internal/testdata/oneofs.pb.h \
|
||||
google/protobuf/util/internal/testdata/proto3.pb.cc \
|
||||
google/protobuf/util/internal/testdata/proto3.pb.h \
|
||||
google/protobuf/util/internal/testdata/struct.pb.cc \
|
||||
google/protobuf/util/internal/testdata/struct.pb.h \
|
||||
google/protobuf/util/internal/testdata/timestamp_duration.pb.cc \
|
||||
google/protobuf/util/internal/testdata/timestamp_duration.pb.h \
|
||||
google/protobuf/util/internal/testdata/wrappers.pb.cc \
|
||||
google/protobuf/util/internal/testdata/wrappers.pb.h \
|
||||
google/protobuf/util/json_format.pb.cc \
|
||||
google/protobuf/util/json_format.pb.h \
|
||||
google/protobuf/util/json_format_proto3.pb.cc \
|
||||
google/protobuf/util/json_format_proto3.pb.h \
|
||||
google/protobuf/util/message_differencer_unittest.pb.cc \
|
||||
google/protobuf/util/message_differencer_unittest.pb.h
|
||||
|
||||
if USE_EXTERNAL_PROTOC
|
||||
|
||||
unittest_proto_middleman: $(protoc_inputs)
|
||||
$(PROTOC) -I$(srcdir) --cpp_out=. $^
|
||||
touch unittest_proto_middleman
|
||||
|
||||
else
|
||||
|
||||
# We have to cd to $(srcdir) before executing protoc because $(protoc_inputs) is
|
||||
# relative to srcdir, which may not be the same as the current directory when
|
||||
# building out-of-tree.
|
||||
unittest_proto_middleman: protoc$(EXEEXT) $(protoc_inputs)
|
||||
oldpwd=`pwd` && ( cd $(srcdir) && $$oldpwd/protoc$(EXEEXT) -I. --cpp_out=$$oldpwd $(protoc_inputs) --experimental_allow_proto3_optional )
|
||||
touch unittest_proto_middleman
|
||||
|
||||
endif
|
||||
|
||||
$(protoc_outputs): unittest_proto_middleman
|
||||
|
||||
COMMON_TEST_SOURCES = \
|
||||
$(COMMON_LITE_TEST_SOURCES) \
|
||||
google/protobuf/compiler/cpp/unittest.h \
|
||||
google/protobuf/map_test_util.h \
|
||||
google/protobuf/map_test_util.inc \
|
||||
google/protobuf/reflection_tester.cc \
|
||||
google/protobuf/reflection_tester.h \
|
||||
google/protobuf/test_util.cc \
|
||||
google/protobuf/test_util.h \
|
||||
google/protobuf/test_util.inc \
|
||||
google/protobuf/test_util2.h \
|
||||
google/protobuf/testing/file.cc \
|
||||
google/protobuf/testing/file.h \
|
||||
google/protobuf/testing/googletest.cc \
|
||||
google/protobuf/testing/googletest.h
|
||||
|
||||
GOOGLETEST_BUILD_DIR=../third_party/googletest/googletest
|
||||
GOOGLEMOCK_BUILD_DIR=../third_party/googletest/googlemock
|
||||
GOOGLETEST_SRC_DIR=$(srcdir)/../third_party/googletest/googletest
|
||||
GOOGLEMOCK_SRC_DIR=$(srcdir)/../third_party/googletest/googlemock
|
||||
check_PROGRAMS = protoc protobuf-test protobuf-lazy-descriptor-test \
|
||||
protobuf-lite-test test_plugin protobuf-lite-arena-test \
|
||||
no-warning-test $(GZCHECKPROGRAMS)
|
||||
protobuf_test_LDADD = $(PTHREAD_LIBS) libprotobuf.la libprotoc.la \
|
||||
$(GOOGLETEST_BUILD_DIR)/lib/libgtest.la \
|
||||
$(GOOGLEMOCK_BUILD_DIR)/lib/libgmock.la \
|
||||
$(GOOGLEMOCK_BUILD_DIR)/lib/libgmock_main.la
|
||||
protobuf_test_CPPFLAGS = -I$(GOOGLETEST_SRC_DIR)/include \
|
||||
-I$(GOOGLEMOCK_SRC_DIR)/include
|
||||
# Disable optimization for tests unless the user explicitly asked for it,
|
||||
# since test_util.cc takes forever to compile with optimization (with GCC).
|
||||
# See configure.ac for more info.
|
||||
protobuf_test_CXXFLAGS = $(NO_OPT_CXXFLAGS)
|
||||
protobuf_test_SOURCES = \
|
||||
$(COMMON_TEST_SOURCES) \
|
||||
google/protobuf/any_test.cc \
|
||||
google/protobuf/arena_unittest.cc \
|
||||
google/protobuf/arenastring_unittest.cc \
|
||||
google/protobuf/arenaz_sampler_test.cc \
|
||||
google/protobuf/compiler/annotation_test_util.cc \
|
||||
google/protobuf/compiler/annotation_test_util.h \
|
||||
google/protobuf/compiler/command_line_interface_unittest.cc \
|
||||
google/protobuf/compiler/cpp/bootstrap_unittest.cc \
|
||||
google/protobuf/compiler/cpp/message_size_unittest.cc \
|
||||
google/protobuf/compiler/cpp/metadata_test.cc \
|
||||
google/protobuf/compiler/cpp/move_unittest.cc \
|
||||
google/protobuf/compiler/cpp/plugin_unittest.cc \
|
||||
google/protobuf/compiler/cpp/unittest.cc \
|
||||
google/protobuf/compiler/cpp/unittest.inc \
|
||||
google/protobuf/compiler/csharp/csharp_bootstrap_unittest.cc \
|
||||
google/protobuf/compiler/csharp/csharp_generator_unittest.cc \
|
||||
google/protobuf/compiler/importer_unittest.cc \
|
||||
google/protobuf/compiler/java/doc_comment_unittest.cc \
|
||||
google/protobuf/compiler/java/plugin_unittest.cc \
|
||||
google/protobuf/compiler/mock_code_generator.cc \
|
||||
google/protobuf/compiler/mock_code_generator.h \
|
||||
google/protobuf/compiler/objectivec/objectivec_helpers_unittest.cc \
|
||||
google/protobuf/compiler/parser_unittest.cc \
|
||||
google/protobuf/compiler/python/plugin_unittest.cc \
|
||||
google/protobuf/compiler/ruby/ruby_generator_unittest.cc \
|
||||
google/protobuf/descriptor_database_unittest.cc \
|
||||
google/protobuf/descriptor_unittest.cc \
|
||||
google/protobuf/drop_unknown_fields_test.cc \
|
||||
google/protobuf/dynamic_message_unittest.cc \
|
||||
google/protobuf/extension_set_unittest.cc \
|
||||
google/protobuf/generated_message_reflection_unittest.cc \
|
||||
google/protobuf/generated_message_tctable_lite_test.cc \
|
||||
google/protobuf/inlined_string_field_unittest.cc \
|
||||
google/protobuf/io/coded_stream_unittest.cc \
|
||||
google/protobuf/io/io_win32_unittest.cc \
|
||||
google/protobuf/io/printer_unittest.cc \
|
||||
google/protobuf/io/tokenizer_unittest.cc \
|
||||
google/protobuf/io/zero_copy_stream_unittest.cc \
|
||||
google/protobuf/map_field_test.cc \
|
||||
google/protobuf/map_test.cc \
|
||||
google/protobuf/map_test.inc \
|
||||
google/protobuf/message_unittest.cc \
|
||||
google/protobuf/message_unittest.inc \
|
||||
google/protobuf/no_field_presence_test.cc \
|
||||
google/protobuf/preserve_unknown_enum_test.cc \
|
||||
google/protobuf/proto3_arena_lite_unittest.cc \
|
||||
google/protobuf/proto3_arena_unittest.cc \
|
||||
google/protobuf/proto3_lite_unittest.cc \
|
||||
google/protobuf/proto3_lite_unittest.inc \
|
||||
google/protobuf/reflection_ops_unittest.cc \
|
||||
google/protobuf/repeated_field_reflection_unittest.cc \
|
||||
google/protobuf/repeated_field_unittest.cc \
|
||||
google/protobuf/stubs/bytestream_unittest.cc \
|
||||
google/protobuf/stubs/common_unittest.cc \
|
||||
google/protobuf/stubs/int128_unittest.cc \
|
||||
google/protobuf/stubs/status_test.cc \
|
||||
google/protobuf/stubs/statusor_test.cc \
|
||||
google/protobuf/stubs/stringpiece_unittest.cc \
|
||||
google/protobuf/stubs/stringprintf_unittest.cc \
|
||||
google/protobuf/stubs/structurally_valid_unittest.cc \
|
||||
google/protobuf/stubs/strutil_unittest.cc \
|
||||
google/protobuf/stubs/template_util_unittest.cc \
|
||||
google/protobuf/stubs/time_test.cc \
|
||||
google/protobuf/text_format_unittest.cc \
|
||||
google/protobuf/unknown_field_set_unittest.cc \
|
||||
google/protobuf/util/delimited_message_util_test.cc \
|
||||
google/protobuf/util/field_comparator_test.cc \
|
||||
google/protobuf/util/field_mask_util_test.cc \
|
||||
google/protobuf/util/internal/default_value_objectwriter_test.cc \
|
||||
google/protobuf/util/internal/json_objectwriter_test.cc \
|
||||
google/protobuf/util/internal/json_stream_parser_test.cc \
|
||||
google/protobuf/util/internal/protostream_objectsource_test.cc \
|
||||
google/protobuf/util/internal/protostream_objectwriter_test.cc \
|
||||
google/protobuf/util/internal/type_info_test_helper.cc \
|
||||
google/protobuf/util/json_util_test.cc \
|
||||
google/protobuf/util/message_differencer_unittest.cc \
|
||||
google/protobuf/util/time_util_test.cc \
|
||||
google/protobuf/util/type_resolver_util_test.cc \
|
||||
google/protobuf/well_known_types_unittest.cc \
|
||||
google/protobuf/wire_format_unittest.cc \
|
||||
google/protobuf/wire_format_unittest.inc
|
||||
|
||||
nodist_protobuf_test_SOURCES = $(protoc_outputs)
|
||||
$(am_protobuf_test_OBJECTS): unittest_proto_middleman
|
||||
|
||||
# Run cpp_unittest again with PROTOBUF_TEST_NO_DESCRIPTORS defined.
|
||||
protobuf_lazy_descriptor_test_LDADD = $(PTHREAD_LIBS) libprotobuf.la \
|
||||
libprotoc.la \
|
||||
$(GOOGLETEST_BUILD_DIR)/lib/libgtest.la \
|
||||
$(GOOGLEMOCK_BUILD_DIR)/lib/libgmock.la \
|
||||
$(GOOGLEMOCK_BUILD_DIR)/lib/libgmock_main.la
|
||||
protobuf_lazy_descriptor_test_CPPFLAGS = -I$(GOOGLEMOCK_SRC_DIR)/include \
|
||||
-I$(GOOGLETEST_SRC_DIR)/include \
|
||||
-DPROTOBUF_TEST_NO_DESCRIPTORS
|
||||
protobuf_lazy_descriptor_test_CXXFLAGS = $(NO_OPT_CXXFLAGS)
|
||||
protobuf_lazy_descriptor_test_SOURCES = \
|
||||
google/protobuf/compiler/cpp/unittest.cc \
|
||||
$(COMMON_TEST_SOURCES)
|
||||
nodist_protobuf_lazy_descriptor_test_SOURCES = $(protoc_outputs)
|
||||
$(am_protobuf_lazy_descriptor_test_OBJECTS): unittest_proto_middleman
|
||||
|
||||
COMMON_LITE_TEST_SOURCES = \
|
||||
google/protobuf/arena_test_util.cc \
|
||||
google/protobuf/arena_test_util.h \
|
||||
google/protobuf/map_lite_test_util.cc \
|
||||
google/protobuf/map_lite_test_util.h \
|
||||
google/protobuf/map_test_util_impl.h \
|
||||
google/protobuf/test_util_lite.cc \
|
||||
google/protobuf/test_util_lite.h
|
||||
|
||||
# Build lite_unittest separately, since it doesn't use gtest. It can't
|
||||
# depend on gtest because our internal version of gtest depend on proto
|
||||
# full runtime and we want to make sure this test builds without full
|
||||
# runtime.
|
||||
protobuf_lite_test_LDADD = $(PTHREAD_LIBS) libprotobuf-lite.la \
|
||||
$(GOOGLETEST_BUILD_DIR)/lib/libgtest.la \
|
||||
$(GOOGLEMOCK_BUILD_DIR)/lib/libgmock.la \
|
||||
$(GOOGLEMOCK_BUILD_DIR)/lib/libgmock_main.la
|
||||
protobuf_lite_test_CPPFLAGS= -I$(GOOGLEMOCK_SRC_DIR)/include \
|
||||
-I$(GOOGLETEST_SRC_DIR)/include
|
||||
protobuf_lite_test_CXXFLAGS = $(NO_OPT_CXXFLAGS)
|
||||
protobuf_lite_test_SOURCES = \
|
||||
google/protobuf/lite_unittest.cc \
|
||||
$(COMMON_LITE_TEST_SOURCES)
|
||||
nodist_protobuf_lite_test_SOURCES = $(protoc_lite_outputs)
|
||||
$(am_protobuf_lite_test_OBJECTS): unittest_proto_middleman
|
||||
|
||||
# lite_arena_unittest depends on gtest because teboring@ found that without
|
||||
# gtest when building the test internally our memory sanitizer doesn't detect
|
||||
# memory leaks (don't know why).
|
||||
protobuf_lite_arena_test_LDADD = $(PTHREAD_LIBS) libprotobuf-lite.la \
|
||||
$(GOOGLETEST_BUILD_DIR)/lib/libgtest.la \
|
||||
$(GOOGLEMOCK_BUILD_DIR)/lib/libgmock.la \
|
||||
$(GOOGLEMOCK_BUILD_DIR)/lib/libgmock_main.la
|
||||
protobuf_lite_arena_test_CPPFLAGS = -I$(GOOGLEMOCK_SRC_DIR)/include \
|
||||
-I$(GOOGLETEST_SRC_DIR)/include
|
||||
protobuf_lite_arena_test_CXXFLAGS = $(NO_OPT_CXXFLAGS)
|
||||
protobuf_lite_arena_test_SOURCES = \
|
||||
google/protobuf/lite_arena_unittest.cc \
|
||||
$(COMMON_LITE_TEST_SOURCES)
|
||||
nodist_protobuf_lite_arena_test_SOURCES = $(protoc_lite_outputs)
|
||||
$(am_protobuf_lite_arena_test_OBJECTS): unittest_proto_middleman
|
||||
|
||||
# Test plugin binary.
|
||||
test_plugin_LDADD = $(PTHREAD_LIBS) libprotobuf.la libprotoc.la \
|
||||
$(GOOGLETEST_BUILD_DIR)/lib/libgtest.la
|
||||
test_plugin_CPPFLAGS = -I$(GOOGLETEST_SRC_DIR)/include
|
||||
test_plugin_SOURCES = \
|
||||
google/protobuf/compiler/mock_code_generator.cc \
|
||||
google/protobuf/compiler/test_plugin.cc \
|
||||
google/protobuf/testing/file.cc \
|
||||
google/protobuf/testing/file.h
|
||||
|
||||
if HAVE_ZLIB
|
||||
zcgzip_LDADD = $(PTHREAD_LIBS) libprotobuf.la
|
||||
zcgzip_SOURCES = google/protobuf/testing/zcgzip.cc
|
||||
|
||||
zcgunzip_LDADD = $(PTHREAD_LIBS) libprotobuf.la
|
||||
zcgunzip_SOURCES = google/protobuf/testing/zcgunzip.cc
|
||||
endif
|
||||
|
||||
# This test target is to ensure all our public header files and generated
|
||||
# code is free from warnings. We have to be more pedantic about these
|
||||
# files because they are compiled by users with different compiler flags.
|
||||
no_warning_test.cc:
|
||||
echo "// Generated from Makefile.am" > no_warning_test.cc
|
||||
for FILE in $(nobase_include_HEADERS); do \
|
||||
case $$FILE in *.inc) continue;; esac; \
|
||||
echo "#include <$${FILE}>" >> no_warning_test.cc; \
|
||||
done
|
||||
echo "int main(int, char**) { return 0; }" >> no_warning_test.cc
|
||||
|
||||
no_warning_test_LDADD = $(PTHREAD_LIBS) libprotobuf.la libprotoc.la
|
||||
no_warning_test_CXXFLAGS = $(PTHREAD_CFLAGS) $(PTHREAD_DEF) $(ZLIB_DEF) \
|
||||
-Wall -Wextra -Werror -Wno-unused-parameter
|
||||
nodist_no_warning_test_SOURCES = no_warning_test.cc $(protoc_outputs)
|
||||
|
||||
TESTS = protobuf-test protobuf-lazy-descriptor-test protobuf-lite-test \
|
||||
google/protobuf/compiler/zip_output_unittest.sh $(GZTESTS) \
|
||||
protobuf-lite-arena-test no-warning-test
|
||||
File diff suppressed because it is too large
Load Diff
@ -0,0 +1,234 @@
|
||||
Protocol Buffers - Google's data interchange format
|
||||
===================================================
|
||||
|
||||
Copyright 2008 Google Inc.
|
||||
|
||||
https://developers.google.com/protocol-buffers/
|
||||
|
||||
C++ Installation - Unix
|
||||
-----------------------
|
||||
|
||||
To build protobuf from source, the following tools are needed:
|
||||
|
||||
* autoconf
|
||||
* automake
|
||||
* libtool
|
||||
* make
|
||||
* g++
|
||||
* unzip
|
||||
|
||||
On Ubuntu/Debian, you can install them with:
|
||||
|
||||
sudo apt-get install autoconf automake libtool curl make g++ unzip
|
||||
|
||||
On other platforms, please use the corresponding package managing tool to
|
||||
install them before proceeding.
|
||||
|
||||
To get the source, download one of the release .tar.gz or .zip packages in the
|
||||
release page:
|
||||
|
||||
https://github.com/protocolbuffers/protobuf/releases/latest
|
||||
|
||||
For example: if you only need C++, download `protobuf-cpp-[VERSION].tar.gz`; if
|
||||
you need C++ and Java, download `protobuf-java-[VERSION].tar.gz` (every package
|
||||
contains C++ source already); if you need C++ and multiple other languages,
|
||||
download `protobuf-all-[VERSION].tar.gz`.
|
||||
|
||||
You can also get the source by "git clone" our git repository. Make sure you
|
||||
have also cloned the submodules and generated the configure script (skip this
|
||||
if you are using a release .tar.gz or .zip package):
|
||||
|
||||
git clone https://github.com/protocolbuffers/protobuf.git
|
||||
cd protobuf
|
||||
git submodule update --init --recursive
|
||||
./autogen.sh
|
||||
|
||||
To build and install the C++ Protocol Buffer runtime and the Protocol
|
||||
Buffer compiler (protoc) execute the following:
|
||||
|
||||
|
||||
./configure
|
||||
make -j$(nproc) # $(nproc) ensures it uses all cores for compilation
|
||||
make check
|
||||
sudo make install
|
||||
sudo ldconfig # refresh shared library cache.
|
||||
|
||||
If "make check" fails, you can still install, but it is likely that
|
||||
some features of this library will not work correctly on your system.
|
||||
Proceed at your own risk.
|
||||
|
||||
For advanced usage information on configure and make, please refer to the
|
||||
autoconf documentation:
|
||||
|
||||
http://www.gnu.org/software/autoconf/manual/autoconf.html#Running-configure-Scripts
|
||||
|
||||
**Hint on install location**
|
||||
|
||||
By default, the package will be installed to /usr/local. However,
|
||||
on many platforms, /usr/local/lib is not part of LD_LIBRARY_PATH.
|
||||
You can add it, but it may be easier to just install to /usr
|
||||
instead. To do this, invoke configure as follows:
|
||||
|
||||
./configure --prefix=/usr
|
||||
|
||||
If you already built the package with a different prefix, make sure
|
||||
to run "make clean" before building again.
|
||||
|
||||
**Compiling dependent packages**
|
||||
|
||||
To compile a package that uses Protocol Buffers, you need to pass
|
||||
various flags to your compiler and linker. As of version 2.2.0,
|
||||
Protocol Buffers integrates with pkg-config to manage this. If you
|
||||
have pkg-config installed, then you can invoke it to get a list of
|
||||
flags like so:
|
||||
|
||||
|
||||
pkg-config --cflags protobuf # print compiler flags
|
||||
pkg-config --libs protobuf # print linker flags
|
||||
pkg-config --cflags --libs protobuf # print both
|
||||
|
||||
|
||||
For example:
|
||||
|
||||
c++ my_program.cc my_proto.pb.cc `pkg-config --cflags --libs protobuf`
|
||||
|
||||
Note that packages written prior to the 2.2.0 release of Protocol
|
||||
Buffers may not yet integrate with pkg-config to get flags, and may
|
||||
not pass the correct set of flags to correctly link against
|
||||
libprotobuf. If the package in question uses autoconf, you can
|
||||
often fix the problem by invoking its configure script like:
|
||||
|
||||
|
||||
configure CXXFLAGS="$(pkg-config --cflags protobuf)" \
|
||||
LIBS="$(pkg-config --libs protobuf)"
|
||||
|
||||
This will force it to use the correct flags.
|
||||
|
||||
If you are writing an autoconf-based package that uses Protocol
|
||||
Buffers, you should probably use the PKG_CHECK_MODULES macro in your
|
||||
configure script like:
|
||||
|
||||
PKG_CHECK_MODULES([protobuf], [protobuf])
|
||||
|
||||
See the pkg-config man page for more info.
|
||||
|
||||
If you only want protobuf-lite, substitute "protobuf-lite" in place
|
||||
of "protobuf" in these examples.
|
||||
|
||||
**Note for Mac users**
|
||||
|
||||
For a Mac system, Unix tools are not available by default. You will first need
|
||||
to install Xcode from the Mac AppStore and then run the following command from
|
||||
a terminal:
|
||||
|
||||
sudo xcode-select --install
|
||||
|
||||
To install Unix tools, you can install "port" following the instructions at
|
||||
https://www.macports.org . This will reside in /opt/local/bin/port for most
|
||||
Mac installations.
|
||||
|
||||
sudo /opt/local/bin/port install autoconf automake libtool
|
||||
|
||||
Alternative for Homebrew users:
|
||||
|
||||
brew install autoconf automake libtool
|
||||
|
||||
Then follow the Unix instructions above.
|
||||
|
||||
**Note for cross-compiling**
|
||||
|
||||
The makefiles normally invoke the protoc executable that they just
|
||||
built in order to build tests. When cross-compiling, the protoc
|
||||
executable may not be executable on the host machine. In this case,
|
||||
you must build a copy of protoc for the host machine first, then use
|
||||
the --with-protoc option to tell configure to use it instead. For
|
||||
example:
|
||||
|
||||
./configure --with-protoc=protoc
|
||||
|
||||
This will use the installed protoc (found in your $PATH) instead of
|
||||
trying to execute the one built during the build process. You can
|
||||
also use an executable that hasn't been installed. For example, if
|
||||
you built the protobuf package for your host machine in ../host,
|
||||
you might do:
|
||||
|
||||
./configure --with-protoc=../host/src/protoc
|
||||
|
||||
Either way, you must make sure that the protoc executable you use
|
||||
has the same version as the protobuf source code you are trying to
|
||||
use it with.
|
||||
|
||||
**Note for Solaris users**
|
||||
|
||||
Solaris 10 x86 has a bug that will make linking fail, complaining
|
||||
about libstdc++.la being invalid. We have included a work-around
|
||||
in this package. To use the work-around, run configure as follows:
|
||||
|
||||
./configure LDFLAGS=-L$PWD/src/solaris
|
||||
|
||||
See src/solaris/libstdc++.la for more info on this bug.
|
||||
|
||||
**Note for HP C++ Tru64 users**
|
||||
|
||||
To compile invoke configure as follows:
|
||||
|
||||
./configure CXXFLAGS="-O -std ansi -ieee -D__USE_STD_IOSTREAM"
|
||||
|
||||
Also, you will need to use gmake instead of make.
|
||||
|
||||
**Note for AIX users**
|
||||
|
||||
Compile using the IBM xlC C++ compiler as follows:
|
||||
|
||||
./configure CXX=xlC
|
||||
|
||||
Also, you will need to use GNU `make` (`gmake`) instead of AIX `make`.
|
||||
|
||||
C++ Installation - Windows
|
||||
--------------------------
|
||||
|
||||
If you only need the protoc binary, you can download it from the release
|
||||
page:
|
||||
|
||||
https://github.com/protocolbuffers/protobuf/releases/latest
|
||||
|
||||
In the downloads section, download the zip file protoc-$VERSION-win32.zip.
|
||||
It contains the protoc binary as well as public proto files of protobuf
|
||||
library.
|
||||
|
||||
Protobuf and its dependencies can be installed directly by using `vcpkg`:
|
||||
|
||||
>vcpkg install protobuf protobuf:x64-windows
|
||||
|
||||
If zlib support is desired, you'll also need to install the zlib feature:
|
||||
|
||||
>vcpkg install protobuf[zlib] protobuf[zlib]:x64-windows
|
||||
|
||||
See https://github.com/Microsoft/vcpkg for more information.
|
||||
|
||||
To build from source using Microsoft Visual C++, see [cmake/README.md](../cmake/README.md).
|
||||
|
||||
To build from source using Cygwin or MinGW, follow the Unix installation
|
||||
instructions, above.
|
||||
|
||||
Binary Compatibility Warning
|
||||
----------------------------
|
||||
|
||||
Due to the nature of C++, it is unlikely that any two versions of the
|
||||
Protocol Buffers C++ runtime libraries will have compatible ABIs.
|
||||
That is, if you linked an executable against an older version of
|
||||
libprotobuf, it is unlikely to work with a newer version without
|
||||
re-compiling. This problem, when it occurs, will normally be detected
|
||||
immediately on startup of your app. Still, you may want to consider
|
||||
using static linkage. You can configure this package to install
|
||||
static libraries only using:
|
||||
|
||||
./configure --disable-shared
|
||||
|
||||
Usage
|
||||
-----
|
||||
|
||||
The complete documentation for Protocol Buffers is available via the
|
||||
web at:
|
||||
|
||||
https://developers.google.com/protocol-buffers/
|
||||
@ -0,0 +1,82 @@
|
||||
// Protocol Buffers - Google's data interchange format
|
||||
// Copyright 2008 Google Inc. All rights reserved.
|
||||
// https://developers.google.com/protocol-buffers/
|
||||
//
|
||||
// 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.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// 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.
|
||||
|
||||
#include <google/protobuf/any.h>
|
||||
|
||||
#include <google/protobuf/arenastring.h>
|
||||
#include <google/protobuf/descriptor.h>
|
||||
#include <google/protobuf/generated_message_util.h>
|
||||
#include <google/protobuf/message.h>
|
||||
|
||||
// Must be included last.
|
||||
#include <google/protobuf/port_def.inc>
|
||||
|
||||
namespace google {
|
||||
namespace protobuf {
|
||||
namespace internal {
|
||||
|
||||
bool AnyMetadata::PackFrom(Arena* arena, const Message& message) {
|
||||
return PackFrom(arena, message, kTypeGoogleApisComPrefix);
|
||||
}
|
||||
|
||||
bool AnyMetadata::PackFrom(Arena* arena, const Message& message,
|
||||
StringPiece type_url_prefix) {
|
||||
type_url_->Set(
|
||||
GetTypeUrl(message.GetDescriptor()->full_name(), type_url_prefix), arena);
|
||||
return message.SerializeToString(value_->Mutable(arena));
|
||||
}
|
||||
|
||||
bool AnyMetadata::UnpackTo(Message* message) const {
|
||||
if (!InternalIs(message->GetDescriptor()->full_name())) {
|
||||
return false;
|
||||
}
|
||||
return message->ParseFromString(value_->Get());
|
||||
}
|
||||
|
||||
bool GetAnyFieldDescriptors(const Message& message,
|
||||
const FieldDescriptor** type_url_field,
|
||||
const FieldDescriptor** value_field) {
|
||||
const Descriptor* descriptor = message.GetDescriptor();
|
||||
if (descriptor->full_name() != kAnyFullTypeName) {
|
||||
return false;
|
||||
}
|
||||
*type_url_field = descriptor->FindFieldByNumber(1);
|
||||
*value_field = descriptor->FindFieldByNumber(2);
|
||||
return (*type_url_field != nullptr &&
|
||||
(*type_url_field)->type() == FieldDescriptor::TYPE_STRING &&
|
||||
*value_field != nullptr &&
|
||||
(*value_field)->type() == FieldDescriptor::TYPE_BYTES);
|
||||
}
|
||||
|
||||
} // namespace internal
|
||||
} // namespace protobuf
|
||||
} // namespace google
|
||||
|
||||
#include <google/protobuf/port_undef.inc>
|
||||
@ -0,0 +1,157 @@
|
||||
// Protocol Buffers - Google's data interchange format
|
||||
// Copyright 2008 Google Inc. All rights reserved.
|
||||
// https://developers.google.com/protocol-buffers/
|
||||
//
|
||||
// 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.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// 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.
|
||||
|
||||
#ifndef GOOGLE_PROTOBUF_ANY_H__
|
||||
#define GOOGLE_PROTOBUF_ANY_H__
|
||||
|
||||
#include <string>
|
||||
|
||||
#include <google/protobuf/stubs/common.h>
|
||||
#include <google/protobuf/arenastring.h>
|
||||
#include <google/protobuf/message_lite.h>
|
||||
|
||||
// Must be included last.
|
||||
#include <google/protobuf/port_def.inc>
|
||||
|
||||
namespace google {
|
||||
namespace protobuf {
|
||||
|
||||
class FieldDescriptor;
|
||||
class Message;
|
||||
|
||||
namespace internal {
|
||||
|
||||
extern const char kAnyFullTypeName[]; // "google.protobuf.Any".
|
||||
extern const char kTypeGoogleApisComPrefix[]; // "type.googleapis.com/".
|
||||
extern const char kTypeGoogleProdComPrefix[]; // "type.googleprod.com/".
|
||||
|
||||
std::string GetTypeUrl(StringPiece message_name,
|
||||
StringPiece type_url_prefix);
|
||||
|
||||
// Helper class used to implement google::protobuf::Any.
|
||||
class PROTOBUF_EXPORT AnyMetadata {
|
||||
typedef ArenaStringPtr UrlType;
|
||||
typedef ArenaStringPtr ValueType;
|
||||
public:
|
||||
// AnyMetadata does not take ownership of "type_url" and "value".
|
||||
constexpr AnyMetadata(UrlType* type_url, ValueType* value)
|
||||
: type_url_(type_url), value_(value) {}
|
||||
|
||||
// Packs a message using the default type URL prefix: "type.googleapis.com".
|
||||
// The resulted type URL will be "type.googleapis.com/<message_full_name>".
|
||||
// Returns false if serializing the message failed.
|
||||
template <typename T>
|
||||
bool PackFrom(Arena* arena, const T& message) {
|
||||
return InternalPackFrom(arena, message, kTypeGoogleApisComPrefix,
|
||||
T::FullMessageName());
|
||||
}
|
||||
|
||||
bool PackFrom(Arena* arena, const Message& message);
|
||||
|
||||
// Packs a message using the given type URL prefix. The type URL will be
|
||||
// constructed by concatenating the message type's full name to the prefix
|
||||
// with an optional "/" separator if the prefix doesn't already end with "/".
|
||||
// For example, both PackFrom(message, "type.googleapis.com") and
|
||||
// PackFrom(message, "type.googleapis.com/") yield the same result type
|
||||
// URL: "type.googleapis.com/<message_full_name>".
|
||||
// Returns false if serializing the message failed.
|
||||
template <typename T>
|
||||
bool PackFrom(Arena* arena, const T& message,
|
||||
StringPiece type_url_prefix) {
|
||||
return InternalPackFrom(arena, message, type_url_prefix,
|
||||
T::FullMessageName());
|
||||
}
|
||||
|
||||
bool PackFrom(Arena* arena, const Message& message,
|
||||
StringPiece type_url_prefix);
|
||||
|
||||
// Unpacks the payload into the given message. Returns false if the message's
|
||||
// type doesn't match the type specified in the type URL (i.e., the full
|
||||
// name after the last "/" of the type URL doesn't match the message's actual
|
||||
// full name) or parsing the payload has failed.
|
||||
template <typename T>
|
||||
bool UnpackTo(T* message) const {
|
||||
return InternalUnpackTo(T::FullMessageName(), message);
|
||||
}
|
||||
|
||||
bool UnpackTo(Message* message) const;
|
||||
|
||||
// Checks whether the type specified in the type URL matches the given type.
|
||||
// A type is considered matching if its full name matches the full name after
|
||||
// the last "/" in the type URL.
|
||||
template <typename T>
|
||||
bool Is() const {
|
||||
return InternalIs(T::FullMessageName());
|
||||
}
|
||||
|
||||
private:
|
||||
bool InternalPackFrom(Arena* arena, const MessageLite& message,
|
||||
StringPiece type_url_prefix,
|
||||
StringPiece type_name);
|
||||
bool InternalUnpackTo(StringPiece type_name,
|
||||
MessageLite* message) const;
|
||||
bool InternalIs(StringPiece type_name) const;
|
||||
|
||||
UrlType* type_url_;
|
||||
ValueType* value_;
|
||||
|
||||
GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(AnyMetadata);
|
||||
};
|
||||
|
||||
// Get the proto type name from Any::type_url value. For example, passing
|
||||
// "type.googleapis.com/rpc.QueryOrigin" will return "rpc.QueryOrigin" in
|
||||
// *full_type_name. Returns false if the type_url does not have a "/"
|
||||
// in the type url separating the full type name.
|
||||
//
|
||||
// NOTE: this function is available publicly as a static method on the
|
||||
// generated message type: google::protobuf::Any::ParseAnyTypeUrl()
|
||||
bool ParseAnyTypeUrl(StringPiece type_url, std::string* full_type_name);
|
||||
|
||||
// Get the proto type name and prefix from Any::type_url value. For example,
|
||||
// passing "type.googleapis.com/rpc.QueryOrigin" will return
|
||||
// "type.googleapis.com/" in *url_prefix and "rpc.QueryOrigin" in
|
||||
// *full_type_name. Returns false if the type_url does not have a "/" in the
|
||||
// type url separating the full type name.
|
||||
bool ParseAnyTypeUrl(StringPiece type_url, std::string* url_prefix,
|
||||
std::string* full_type_name);
|
||||
|
||||
// See if message is of type google.protobuf.Any, if so, return the descriptors
|
||||
// for "type_url" and "value" fields.
|
||||
bool GetAnyFieldDescriptors(const Message& message,
|
||||
const FieldDescriptor** type_url_field,
|
||||
const FieldDescriptor** value_field);
|
||||
|
||||
} // namespace internal
|
||||
} // namespace protobuf
|
||||
} // namespace google
|
||||
|
||||
#include <google/protobuf/port_undef.inc>
|
||||
|
||||
#endif // GOOGLE_PROTOBUF_ANY_H__
|
||||
@ -0,0 +1,368 @@
|
||||
// Generated by the protocol buffer compiler. DO NOT EDIT!
|
||||
// source: google/protobuf/any.proto
|
||||
|
||||
#include <google/protobuf/any.pb.h>
|
||||
|
||||
#include <algorithm>
|
||||
|
||||
#include <google/protobuf/io/coded_stream.h>
|
||||
#include <google/protobuf/extension_set.h>
|
||||
#include <google/protobuf/wire_format_lite.h>
|
||||
#include <google/protobuf/descriptor.h>
|
||||
#include <google/protobuf/generated_message_reflection.h>
|
||||
#include <google/protobuf/reflection_ops.h>
|
||||
#include <google/protobuf/wire_format.h>
|
||||
// @@protoc_insertion_point(includes)
|
||||
#include <google/protobuf/port_def.inc>
|
||||
|
||||
PROTOBUF_PRAGMA_INIT_SEG
|
||||
|
||||
namespace _pb = ::PROTOBUF_NAMESPACE_ID;
|
||||
namespace _pbi = _pb::internal;
|
||||
|
||||
#if defined(__llvm__)
|
||||
#pragma clang diagnostic push
|
||||
#pragma clang diagnostic ignored "-Wuninitialized"
|
||||
#endif // __llvm__
|
||||
PROTOBUF_NAMESPACE_OPEN
|
||||
PROTOBUF_CONSTEXPR Any::Any(
|
||||
::_pbi::ConstantInitialized): _impl_{
|
||||
/*decltype(_impl_.type_url_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
|
||||
, /*decltype(_impl_.value_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
|
||||
, /*decltype(_impl_._cached_size_)*/{}
|
||||
, /*decltype(_impl_._any_metadata_)*/{&_impl_.type_url_, &_impl_.value_}} {}
|
||||
struct AnyDefaultTypeInternal {
|
||||
PROTOBUF_CONSTEXPR AnyDefaultTypeInternal()
|
||||
: _instance(::_pbi::ConstantInitialized{}) {}
|
||||
~AnyDefaultTypeInternal() {}
|
||||
union {
|
||||
Any _instance;
|
||||
};
|
||||
};
|
||||
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 AnyDefaultTypeInternal _Any_default_instance_;
|
||||
PROTOBUF_NAMESPACE_CLOSE
|
||||
static ::_pb::Metadata file_level_metadata_google_2fprotobuf_2fany_2eproto[1];
|
||||
static constexpr ::_pb::EnumDescriptor const** file_level_enum_descriptors_google_2fprotobuf_2fany_2eproto = nullptr;
|
||||
static constexpr ::_pb::ServiceDescriptor const** file_level_service_descriptors_google_2fprotobuf_2fany_2eproto = nullptr;
|
||||
|
||||
const uint32_t TableStruct_google_2fprotobuf_2fany_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
|
||||
~0u, // no _has_bits_
|
||||
PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::Any, _internal_metadata_),
|
||||
~0u, // no _extensions_
|
||||
~0u, // no _oneof_case_
|
||||
~0u, // no _weak_field_map_
|
||||
~0u, // no _inlined_string_donated_
|
||||
PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::Any, _impl_.type_url_),
|
||||
PROTOBUF_FIELD_OFFSET(::PROTOBUF_NAMESPACE_ID::Any, _impl_.value_),
|
||||
};
|
||||
static const ::_pbi::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
|
||||
{ 0, -1, -1, sizeof(::PROTOBUF_NAMESPACE_ID::Any)},
|
||||
};
|
||||
|
||||
static const ::_pb::Message* const file_default_instances[] = {
|
||||
&::PROTOBUF_NAMESPACE_ID::_Any_default_instance_._instance,
|
||||
};
|
||||
|
||||
const char descriptor_table_protodef_google_2fprotobuf_2fany_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) =
|
||||
"\n\031google/protobuf/any.proto\022\017google.prot"
|
||||
"obuf\"&\n\003Any\022\020\n\010type_url\030\001 \001(\t\022\r\n\005value\030\002"
|
||||
" \001(\014Bv\n\023com.google.protobufB\010AnyProtoP\001Z"
|
||||
",google.golang.org/protobuf/types/known/"
|
||||
"anypb\242\002\003GPB\252\002\036Google.Protobuf.WellKnownT"
|
||||
"ypesb\006proto3"
|
||||
;
|
||||
static ::_pbi::once_flag descriptor_table_google_2fprotobuf_2fany_2eproto_once;
|
||||
const ::_pbi::DescriptorTable descriptor_table_google_2fprotobuf_2fany_2eproto = {
|
||||
false, false, 212, descriptor_table_protodef_google_2fprotobuf_2fany_2eproto,
|
||||
"google/protobuf/any.proto",
|
||||
&descriptor_table_google_2fprotobuf_2fany_2eproto_once, nullptr, 0, 1,
|
||||
schemas, file_default_instances, TableStruct_google_2fprotobuf_2fany_2eproto::offsets,
|
||||
file_level_metadata_google_2fprotobuf_2fany_2eproto, file_level_enum_descriptors_google_2fprotobuf_2fany_2eproto,
|
||||
file_level_service_descriptors_google_2fprotobuf_2fany_2eproto,
|
||||
};
|
||||
PROTOBUF_ATTRIBUTE_WEAK const ::_pbi::DescriptorTable* descriptor_table_google_2fprotobuf_2fany_2eproto_getter() {
|
||||
return &descriptor_table_google_2fprotobuf_2fany_2eproto;
|
||||
}
|
||||
|
||||
// Force running AddDescriptors() at dynamic initialization time.
|
||||
PROTOBUF_ATTRIBUTE_INIT_PRIORITY2 static ::_pbi::AddDescriptorsRunner dynamic_init_dummy_google_2fprotobuf_2fany_2eproto(&descriptor_table_google_2fprotobuf_2fany_2eproto);
|
||||
PROTOBUF_NAMESPACE_OPEN
|
||||
|
||||
// ===================================================================
|
||||
|
||||
bool Any::GetAnyFieldDescriptors(
|
||||
const ::PROTOBUF_NAMESPACE_ID::Message& message,
|
||||
const ::PROTOBUF_NAMESPACE_ID::FieldDescriptor** type_url_field,
|
||||
const ::PROTOBUF_NAMESPACE_ID::FieldDescriptor** value_field) {
|
||||
return ::_pbi::GetAnyFieldDescriptors(
|
||||
message, type_url_field, value_field);
|
||||
}
|
||||
bool Any::ParseAnyTypeUrl(
|
||||
::PROTOBUF_NAMESPACE_ID::ConstStringParam type_url,
|
||||
std::string* full_type_name) {
|
||||
return ::_pbi::ParseAnyTypeUrl(type_url, full_type_name);
|
||||
}
|
||||
|
||||
class Any::_Internal {
|
||||
public:
|
||||
};
|
||||
|
||||
Any::Any(::PROTOBUF_NAMESPACE_ID::Arena* arena,
|
||||
bool is_message_owned)
|
||||
: ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
|
||||
SharedCtor(arena, is_message_owned);
|
||||
// @@protoc_insertion_point(arena_constructor:google.protobuf.Any)
|
||||
}
|
||||
Any::Any(const Any& from)
|
||||
: ::PROTOBUF_NAMESPACE_ID::Message() {
|
||||
Any* const _this = this; (void)_this;
|
||||
new (&_impl_) Impl_{
|
||||
decltype(_impl_.type_url_){}
|
||||
, decltype(_impl_.value_){}
|
||||
, /*decltype(_impl_._cached_size_)*/{}
|
||||
, /*decltype(_impl_._any_metadata_)*/{&_impl_.type_url_, &_impl_.value_}};
|
||||
|
||||
_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
|
||||
_impl_.type_url_.InitDefault();
|
||||
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
|
||||
_impl_.type_url_.Set("", GetArenaForAllocation());
|
||||
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
|
||||
if (!from._internal_type_url().empty()) {
|
||||
_this->_impl_.type_url_.Set(from._internal_type_url(),
|
||||
_this->GetArenaForAllocation());
|
||||
}
|
||||
_impl_.value_.InitDefault();
|
||||
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
|
||||
_impl_.value_.Set("", GetArenaForAllocation());
|
||||
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
|
||||
if (!from._internal_value().empty()) {
|
||||
_this->_impl_.value_.Set(from._internal_value(),
|
||||
_this->GetArenaForAllocation());
|
||||
}
|
||||
// @@protoc_insertion_point(copy_constructor:google.protobuf.Any)
|
||||
}
|
||||
|
||||
inline void Any::SharedCtor(
|
||||
::_pb::Arena* arena, bool is_message_owned) {
|
||||
(void)arena;
|
||||
(void)is_message_owned;
|
||||
new (&_impl_) Impl_{
|
||||
decltype(_impl_.type_url_){}
|
||||
, decltype(_impl_.value_){}
|
||||
, /*decltype(_impl_._cached_size_)*/{}
|
||||
, /*decltype(_impl_._any_metadata_)*/{&_impl_.type_url_, &_impl_.value_}
|
||||
};
|
||||
_impl_.type_url_.InitDefault();
|
||||
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
|
||||
_impl_.type_url_.Set("", GetArenaForAllocation());
|
||||
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
|
||||
_impl_.value_.InitDefault();
|
||||
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
|
||||
_impl_.value_.Set("", GetArenaForAllocation());
|
||||
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
|
||||
}
|
||||
|
||||
Any::~Any() {
|
||||
// @@protoc_insertion_point(destructor:google.protobuf.Any)
|
||||
if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
|
||||
(void)arena;
|
||||
return;
|
||||
}
|
||||
SharedDtor();
|
||||
}
|
||||
|
||||
inline void Any::SharedDtor() {
|
||||
GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
|
||||
_impl_.type_url_.Destroy();
|
||||
_impl_.value_.Destroy();
|
||||
_impl_._any_metadata_.~AnyMetadata();
|
||||
}
|
||||
|
||||
void Any::SetCachedSize(int size) const {
|
||||
_impl_._cached_size_.Set(size);
|
||||
}
|
||||
|
||||
void Any::Clear() {
|
||||
// @@protoc_insertion_point(message_clear_start:google.protobuf.Any)
|
||||
uint32_t cached_has_bits = 0;
|
||||
// Prevent compiler warnings about cached_has_bits being unused
|
||||
(void) cached_has_bits;
|
||||
|
||||
_impl_.type_url_.ClearToEmpty();
|
||||
_impl_.value_.ClearToEmpty();
|
||||
_internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
|
||||
}
|
||||
|
||||
const char* Any::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
|
||||
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
|
||||
while (!ctx->Done(&ptr)) {
|
||||
uint32_t tag;
|
||||
ptr = ::_pbi::ReadTag(ptr, &tag);
|
||||
switch (tag >> 3) {
|
||||
// string type_url = 1;
|
||||
case 1:
|
||||
if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
|
||||
auto str = _internal_mutable_type_url();
|
||||
ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
|
||||
CHK_(ptr);
|
||||
CHK_(::_pbi::VerifyUTF8(str, "google.protobuf.Any.type_url"));
|
||||
} else
|
||||
goto handle_unusual;
|
||||
continue;
|
||||
// bytes value = 2;
|
||||
case 2:
|
||||
if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
|
||||
auto str = _internal_mutable_value();
|
||||
ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
|
||||
CHK_(ptr);
|
||||
} else
|
||||
goto handle_unusual;
|
||||
continue;
|
||||
default:
|
||||
goto handle_unusual;
|
||||
} // switch
|
||||
handle_unusual:
|
||||
if ((tag == 0) || ((tag & 7) == 4)) {
|
||||
CHK_(ptr);
|
||||
ctx->SetLastTag(tag);
|
||||
goto message_done;
|
||||
}
|
||||
ptr = UnknownFieldParse(
|
||||
tag,
|
||||
_internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
|
||||
ptr, ctx);
|
||||
CHK_(ptr != nullptr);
|
||||
} // while
|
||||
message_done:
|
||||
return ptr;
|
||||
failure:
|
||||
ptr = nullptr;
|
||||
goto message_done;
|
||||
#undef CHK_
|
||||
}
|
||||
|
||||
uint8_t* Any::_InternalSerialize(
|
||||
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
|
||||
// @@protoc_insertion_point(serialize_to_array_start:google.protobuf.Any)
|
||||
uint32_t cached_has_bits = 0;
|
||||
(void) cached_has_bits;
|
||||
|
||||
// string type_url = 1;
|
||||
if (!this->_internal_type_url().empty()) {
|
||||
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
|
||||
this->_internal_type_url().data(), static_cast<int>(this->_internal_type_url().length()),
|
||||
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
|
||||
"google.protobuf.Any.type_url");
|
||||
target = stream->WriteStringMaybeAliased(
|
||||
1, this->_internal_type_url(), target);
|
||||
}
|
||||
|
||||
// bytes value = 2;
|
||||
if (!this->_internal_value().empty()) {
|
||||
target = stream->WriteBytesMaybeAliased(
|
||||
2, this->_internal_value(), target);
|
||||
}
|
||||
|
||||
if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
|
||||
target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
|
||||
_internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
|
||||
}
|
||||
// @@protoc_insertion_point(serialize_to_array_end:google.protobuf.Any)
|
||||
return target;
|
||||
}
|
||||
|
||||
size_t Any::ByteSizeLong() const {
|
||||
// @@protoc_insertion_point(message_byte_size_start:google.protobuf.Any)
|
||||
size_t total_size = 0;
|
||||
|
||||
uint32_t cached_has_bits = 0;
|
||||
// Prevent compiler warnings about cached_has_bits being unused
|
||||
(void) cached_has_bits;
|
||||
|
||||
// string type_url = 1;
|
||||
if (!this->_internal_type_url().empty()) {
|
||||
total_size += 1 +
|
||||
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
|
||||
this->_internal_type_url());
|
||||
}
|
||||
|
||||
// bytes value = 2;
|
||||
if (!this->_internal_value().empty()) {
|
||||
total_size += 1 +
|
||||
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
|
||||
this->_internal_value());
|
||||
}
|
||||
|
||||
return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
|
||||
}
|
||||
|
||||
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Any::_class_data_ = {
|
||||
::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
|
||||
Any::MergeImpl
|
||||
};
|
||||
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Any::GetClassData() const { return &_class_data_; }
|
||||
|
||||
|
||||
void Any::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
|
||||
auto* const _this = static_cast<Any*>(&to_msg);
|
||||
auto& from = static_cast<const Any&>(from_msg);
|
||||
// @@protoc_insertion_point(class_specific_merge_from_start:google.protobuf.Any)
|
||||
GOOGLE_DCHECK_NE(&from, _this);
|
||||
uint32_t cached_has_bits = 0;
|
||||
(void) cached_has_bits;
|
||||
|
||||
if (!from._internal_type_url().empty()) {
|
||||
_this->_internal_set_type_url(from._internal_type_url());
|
||||
}
|
||||
if (!from._internal_value().empty()) {
|
||||
_this->_internal_set_value(from._internal_value());
|
||||
}
|
||||
_this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
|
||||
}
|
||||
|
||||
void Any::CopyFrom(const Any& from) {
|
||||
// @@protoc_insertion_point(class_specific_copy_from_start:google.protobuf.Any)
|
||||
if (&from == this) return;
|
||||
Clear();
|
||||
MergeFrom(from);
|
||||
}
|
||||
|
||||
bool Any::IsInitialized() const {
|
||||
return true;
|
||||
}
|
||||
|
||||
void Any::InternalSwap(Any* other) {
|
||||
using std::swap;
|
||||
auto* lhs_arena = GetArenaForAllocation();
|
||||
auto* rhs_arena = other->GetArenaForAllocation();
|
||||
_internal_metadata_.InternalSwap(&other->_internal_metadata_);
|
||||
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
|
||||
&_impl_.type_url_, lhs_arena,
|
||||
&other->_impl_.type_url_, rhs_arena
|
||||
);
|
||||
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
|
||||
&_impl_.value_, lhs_arena,
|
||||
&other->_impl_.value_, rhs_arena
|
||||
);
|
||||
}
|
||||
|
||||
::PROTOBUF_NAMESPACE_ID::Metadata Any::GetMetadata() const {
|
||||
return ::_pbi::AssignDescriptors(
|
||||
&descriptor_table_google_2fprotobuf_2fany_2eproto_getter, &descriptor_table_google_2fprotobuf_2fany_2eproto_once,
|
||||
file_level_metadata_google_2fprotobuf_2fany_2eproto[0]);
|
||||
}
|
||||
|
||||
// @@protoc_insertion_point(namespace_scope)
|
||||
PROTOBUF_NAMESPACE_CLOSE
|
||||
PROTOBUF_NAMESPACE_OPEN
|
||||
template<> PROTOBUF_NOINLINE ::PROTOBUF_NAMESPACE_ID::Any*
|
||||
Arena::CreateMaybeMessage< ::PROTOBUF_NAMESPACE_ID::Any >(Arena* arena) {
|
||||
return Arena::CreateMessageInternal< ::PROTOBUF_NAMESPACE_ID::Any >(arena);
|
||||
}
|
||||
PROTOBUF_NAMESPACE_CLOSE
|
||||
|
||||
// @@protoc_insertion_point(global_scope)
|
||||
#if defined(__llvm__)
|
||||
#pragma clang diagnostic pop
|
||||
#endif // __llvm__
|
||||
#include <google/protobuf/port_undef.inc>
|
||||
@ -0,0 +1,384 @@
|
||||
// Generated by the protocol buffer compiler. DO NOT EDIT!
|
||||
// source: google/protobuf/any.proto
|
||||
|
||||
#ifndef GOOGLE_PROTOBUF_INCLUDED_google_2fprotobuf_2fany_2eproto
|
||||
#define GOOGLE_PROTOBUF_INCLUDED_google_2fprotobuf_2fany_2eproto
|
||||
|
||||
#include <limits>
|
||||
#include <string>
|
||||
|
||||
#include <google/protobuf/port_def.inc>
|
||||
#if PROTOBUF_VERSION < 3021000
|
||||
#error This file was generated by a newer version of protoc which is
|
||||
#error incompatible with your Protocol Buffer headers. Please update
|
||||
#error your headers.
|
||||
#endif
|
||||
#if 3021010 < PROTOBUF_MIN_PROTOC_VERSION
|
||||
#error This file was generated by an older version of protoc which is
|
||||
#error incompatible with your Protocol Buffer headers. Please
|
||||
#error regenerate this file with a newer version of protoc.
|
||||
#endif
|
||||
|
||||
#include <google/protobuf/port_undef.inc>
|
||||
#include <google/protobuf/io/coded_stream.h>
|
||||
#include <google/protobuf/arena.h>
|
||||
#include <google/protobuf/arenastring.h>
|
||||
#include <google/protobuf/generated_message_util.h>
|
||||
#include <google/protobuf/metadata_lite.h>
|
||||
#include <google/protobuf/generated_message_reflection.h>
|
||||
#include <google/protobuf/message.h>
|
||||
#include <google/protobuf/repeated_field.h> // IWYU pragma: export
|
||||
#include <google/protobuf/extension_set.h> // IWYU pragma: export
|
||||
#include <google/protobuf/unknown_field_set.h>
|
||||
// @@protoc_insertion_point(includes)
|
||||
#include <google/protobuf/port_def.inc>
|
||||
#define PROTOBUF_INTERNAL_EXPORT_google_2fprotobuf_2fany_2eproto PROTOBUF_EXPORT
|
||||
PROTOBUF_NAMESPACE_OPEN
|
||||
namespace internal {
|
||||
class AnyMetadata;
|
||||
} // namespace internal
|
||||
PROTOBUF_NAMESPACE_CLOSE
|
||||
|
||||
// Internal implementation detail -- do not use these members.
|
||||
struct PROTOBUF_EXPORT TableStruct_google_2fprotobuf_2fany_2eproto {
|
||||
static const uint32_t offsets[];
|
||||
};
|
||||
PROTOBUF_EXPORT extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_google_2fprotobuf_2fany_2eproto;
|
||||
PROTOBUF_NAMESPACE_OPEN
|
||||
class Any;
|
||||
struct AnyDefaultTypeInternal;
|
||||
PROTOBUF_EXPORT extern AnyDefaultTypeInternal _Any_default_instance_;
|
||||
PROTOBUF_NAMESPACE_CLOSE
|
||||
PROTOBUF_NAMESPACE_OPEN
|
||||
template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::Any* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::Any>(Arena*);
|
||||
PROTOBUF_NAMESPACE_CLOSE
|
||||
PROTOBUF_NAMESPACE_OPEN
|
||||
|
||||
// ===================================================================
|
||||
|
||||
class PROTOBUF_EXPORT Any final :
|
||||
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.Any) */ {
|
||||
public:
|
||||
inline Any() : Any(nullptr) {}
|
||||
~Any() override;
|
||||
explicit PROTOBUF_CONSTEXPR Any(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
|
||||
|
||||
Any(const Any& from);
|
||||
Any(Any&& from) noexcept
|
||||
: Any() {
|
||||
*this = ::std::move(from);
|
||||
}
|
||||
|
||||
inline Any& operator=(const Any& from) {
|
||||
CopyFrom(from);
|
||||
return *this;
|
||||
}
|
||||
inline Any& operator=(Any&& from) noexcept {
|
||||
if (this == &from) return *this;
|
||||
if (GetOwningArena() == from.GetOwningArena()
|
||||
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
|
||||
&& GetOwningArena() != nullptr
|
||||
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
|
||||
) {
|
||||
InternalSwap(&from);
|
||||
} else {
|
||||
CopyFrom(from);
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
|
||||
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
|
||||
return GetDescriptor();
|
||||
}
|
||||
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
|
||||
return default_instance().GetMetadata().descriptor;
|
||||
}
|
||||
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
|
||||
return default_instance().GetMetadata().reflection;
|
||||
}
|
||||
static const Any& default_instance() {
|
||||
return *internal_default_instance();
|
||||
}
|
||||
static inline const Any* internal_default_instance() {
|
||||
return reinterpret_cast<const Any*>(
|
||||
&_Any_default_instance_);
|
||||
}
|
||||
static constexpr int kIndexInFileMessages =
|
||||
0;
|
||||
|
||||
// implements Any -----------------------------------------------
|
||||
|
||||
bool PackFrom(const ::PROTOBUF_NAMESPACE_ID::Message& message) {
|
||||
GOOGLE_DCHECK_NE(&message, this);
|
||||
return _impl_._any_metadata_.PackFrom(GetArena(), message);
|
||||
}
|
||||
bool PackFrom(const ::PROTOBUF_NAMESPACE_ID::Message& message,
|
||||
::PROTOBUF_NAMESPACE_ID::ConstStringParam type_url_prefix) {
|
||||
GOOGLE_DCHECK_NE(&message, this);
|
||||
return _impl_._any_metadata_.PackFrom(GetArena(), message, type_url_prefix);
|
||||
}
|
||||
bool UnpackTo(::PROTOBUF_NAMESPACE_ID::Message* message) const {
|
||||
return _impl_._any_metadata_.UnpackTo(message);
|
||||
}
|
||||
static bool GetAnyFieldDescriptors(
|
||||
const ::PROTOBUF_NAMESPACE_ID::Message& message,
|
||||
const ::PROTOBUF_NAMESPACE_ID::FieldDescriptor** type_url_field,
|
||||
const ::PROTOBUF_NAMESPACE_ID::FieldDescriptor** value_field);
|
||||
template <typename T, class = typename std::enable_if<!std::is_convertible<T, const ::PROTOBUF_NAMESPACE_ID::Message&>::value>::type>
|
||||
bool PackFrom(const T& message) {
|
||||
return _impl_._any_metadata_.PackFrom<T>(GetArena(), message);
|
||||
}
|
||||
template <typename T, class = typename std::enable_if<!std::is_convertible<T, const ::PROTOBUF_NAMESPACE_ID::Message&>::value>::type>
|
||||
bool PackFrom(const T& message,
|
||||
::PROTOBUF_NAMESPACE_ID::ConstStringParam type_url_prefix) {
|
||||
return _impl_._any_metadata_.PackFrom<T>(GetArena(), message, type_url_prefix);}
|
||||
template <typename T, class = typename std::enable_if<!std::is_convertible<T, const ::PROTOBUF_NAMESPACE_ID::Message&>::value>::type>
|
||||
bool UnpackTo(T* message) const {
|
||||
return _impl_._any_metadata_.UnpackTo<T>(message);
|
||||
}
|
||||
template<typename T> bool Is() const {
|
||||
return _impl_._any_metadata_.Is<T>();
|
||||
}
|
||||
static bool ParseAnyTypeUrl(::PROTOBUF_NAMESPACE_ID::ConstStringParam type_url,
|
||||
std::string* full_type_name);
|
||||
friend void swap(Any& a, Any& b) {
|
||||
a.Swap(&b);
|
||||
}
|
||||
inline void Swap(Any* other) {
|
||||
if (other == this) return;
|
||||
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
|
||||
if (GetOwningArena() != nullptr &&
|
||||
GetOwningArena() == other->GetOwningArena()) {
|
||||
#else // PROTOBUF_FORCE_COPY_IN_SWAP
|
||||
if (GetOwningArena() == other->GetOwningArena()) {
|
||||
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
|
||||
InternalSwap(other);
|
||||
} else {
|
||||
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
|
||||
}
|
||||
}
|
||||
void UnsafeArenaSwap(Any* other) {
|
||||
if (other == this) return;
|
||||
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
|
||||
InternalSwap(other);
|
||||
}
|
||||
|
||||
// implements Message ----------------------------------------------
|
||||
|
||||
Any* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
|
||||
return CreateMaybeMessage<Any>(arena);
|
||||
}
|
||||
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
|
||||
void CopyFrom(const Any& from);
|
||||
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
|
||||
void MergeFrom( const Any& from) {
|
||||
Any::MergeImpl(*this, from);
|
||||
}
|
||||
private:
|
||||
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
|
||||
public:
|
||||
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
|
||||
bool IsInitialized() const final;
|
||||
|
||||
size_t ByteSizeLong() const final;
|
||||
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
|
||||
uint8_t* _InternalSerialize(
|
||||
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
|
||||
int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
|
||||
|
||||
private:
|
||||
void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
|
||||
void SharedDtor();
|
||||
void SetCachedSize(int size) const final;
|
||||
void InternalSwap(Any* other);
|
||||
|
||||
private:
|
||||
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
|
||||
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
|
||||
return "google.protobuf.Any";
|
||||
}
|
||||
protected:
|
||||
explicit Any(::PROTOBUF_NAMESPACE_ID::Arena* arena,
|
||||
bool is_message_owned = false);
|
||||
public:
|
||||
|
||||
static const ClassData _class_data_;
|
||||
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
|
||||
|
||||
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
|
||||
|
||||
// nested types ----------------------------------------------------
|
||||
|
||||
// accessors -------------------------------------------------------
|
||||
|
||||
enum : int {
|
||||
kTypeUrlFieldNumber = 1,
|
||||
kValueFieldNumber = 2,
|
||||
};
|
||||
// string type_url = 1;
|
||||
void clear_type_url();
|
||||
const std::string& type_url() const;
|
||||
template <typename ArgT0 = const std::string&, typename... ArgT>
|
||||
void set_type_url(ArgT0&& arg0, ArgT... args);
|
||||
std::string* mutable_type_url();
|
||||
PROTOBUF_NODISCARD std::string* release_type_url();
|
||||
void set_allocated_type_url(std::string* type_url);
|
||||
private:
|
||||
const std::string& _internal_type_url() const;
|
||||
inline PROTOBUF_ALWAYS_INLINE void _internal_set_type_url(const std::string& value);
|
||||
std::string* _internal_mutable_type_url();
|
||||
public:
|
||||
|
||||
// bytes value = 2;
|
||||
void clear_value();
|
||||
const std::string& value() const;
|
||||
template <typename ArgT0 = const std::string&, typename... ArgT>
|
||||
void set_value(ArgT0&& arg0, ArgT... args);
|
||||
std::string* mutable_value();
|
||||
PROTOBUF_NODISCARD std::string* release_value();
|
||||
void set_allocated_value(std::string* value);
|
||||
private:
|
||||
const std::string& _internal_value() const;
|
||||
inline PROTOBUF_ALWAYS_INLINE void _internal_set_value(const std::string& value);
|
||||
std::string* _internal_mutable_value();
|
||||
public:
|
||||
|
||||
// @@protoc_insertion_point(class_scope:google.protobuf.Any)
|
||||
private:
|
||||
class _Internal;
|
||||
|
||||
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
|
||||
typedef void InternalArenaConstructable_;
|
||||
typedef void DestructorSkippable_;
|
||||
struct Impl_ {
|
||||
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr type_url_;
|
||||
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr value_;
|
||||
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
|
||||
::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata _any_metadata_;
|
||||
};
|
||||
union { Impl_ _impl_; };
|
||||
friend struct ::TableStruct_google_2fprotobuf_2fany_2eproto;
|
||||
};
|
||||
// ===================================================================
|
||||
|
||||
|
||||
// ===================================================================
|
||||
|
||||
#ifdef __GNUC__
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wstrict-aliasing"
|
||||
#endif // __GNUC__
|
||||
// Any
|
||||
|
||||
// string type_url = 1;
|
||||
inline void Any::clear_type_url() {
|
||||
_impl_.type_url_.ClearToEmpty();
|
||||
}
|
||||
inline const std::string& Any::type_url() const {
|
||||
// @@protoc_insertion_point(field_get:google.protobuf.Any.type_url)
|
||||
return _internal_type_url();
|
||||
}
|
||||
template <typename ArgT0, typename... ArgT>
|
||||
inline PROTOBUF_ALWAYS_INLINE
|
||||
void Any::set_type_url(ArgT0&& arg0, ArgT... args) {
|
||||
|
||||
_impl_.type_url_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
|
||||
// @@protoc_insertion_point(field_set:google.protobuf.Any.type_url)
|
||||
}
|
||||
inline std::string* Any::mutable_type_url() {
|
||||
std::string* _s = _internal_mutable_type_url();
|
||||
// @@protoc_insertion_point(field_mutable:google.protobuf.Any.type_url)
|
||||
return _s;
|
||||
}
|
||||
inline const std::string& Any::_internal_type_url() const {
|
||||
return _impl_.type_url_.Get();
|
||||
}
|
||||
inline void Any::_internal_set_type_url(const std::string& value) {
|
||||
|
||||
_impl_.type_url_.Set(value, GetArenaForAllocation());
|
||||
}
|
||||
inline std::string* Any::_internal_mutable_type_url() {
|
||||
|
||||
return _impl_.type_url_.Mutable(GetArenaForAllocation());
|
||||
}
|
||||
inline std::string* Any::release_type_url() {
|
||||
// @@protoc_insertion_point(field_release:google.protobuf.Any.type_url)
|
||||
return _impl_.type_url_.Release();
|
||||
}
|
||||
inline void Any::set_allocated_type_url(std::string* type_url) {
|
||||
if (type_url != nullptr) {
|
||||
|
||||
} else {
|
||||
|
||||
}
|
||||
_impl_.type_url_.SetAllocated(type_url, GetArenaForAllocation());
|
||||
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
|
||||
if (_impl_.type_url_.IsDefault()) {
|
||||
_impl_.type_url_.Set("", GetArenaForAllocation());
|
||||
}
|
||||
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
|
||||
// @@protoc_insertion_point(field_set_allocated:google.protobuf.Any.type_url)
|
||||
}
|
||||
|
||||
// bytes value = 2;
|
||||
inline void Any::clear_value() {
|
||||
_impl_.value_.ClearToEmpty();
|
||||
}
|
||||
inline const std::string& Any::value() const {
|
||||
// @@protoc_insertion_point(field_get:google.protobuf.Any.value)
|
||||
return _internal_value();
|
||||
}
|
||||
template <typename ArgT0, typename... ArgT>
|
||||
inline PROTOBUF_ALWAYS_INLINE
|
||||
void Any::set_value(ArgT0&& arg0, ArgT... args) {
|
||||
|
||||
_impl_.value_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
|
||||
// @@protoc_insertion_point(field_set:google.protobuf.Any.value)
|
||||
}
|
||||
inline std::string* Any::mutable_value() {
|
||||
std::string* _s = _internal_mutable_value();
|
||||
// @@protoc_insertion_point(field_mutable:google.protobuf.Any.value)
|
||||
return _s;
|
||||
}
|
||||
inline const std::string& Any::_internal_value() const {
|
||||
return _impl_.value_.Get();
|
||||
}
|
||||
inline void Any::_internal_set_value(const std::string& value) {
|
||||
|
||||
_impl_.value_.Set(value, GetArenaForAllocation());
|
||||
}
|
||||
inline std::string* Any::_internal_mutable_value() {
|
||||
|
||||
return _impl_.value_.Mutable(GetArenaForAllocation());
|
||||
}
|
||||
inline std::string* Any::release_value() {
|
||||
// @@protoc_insertion_point(field_release:google.protobuf.Any.value)
|
||||
return _impl_.value_.Release();
|
||||
}
|
||||
inline void Any::set_allocated_value(std::string* value) {
|
||||
if (value != nullptr) {
|
||||
|
||||
} else {
|
||||
|
||||
}
|
||||
_impl_.value_.SetAllocated(value, GetArenaForAllocation());
|
||||
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
|
||||
if (_impl_.value_.IsDefault()) {
|
||||
_impl_.value_.Set("", GetArenaForAllocation());
|
||||
}
|
||||
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
|
||||
// @@protoc_insertion_point(field_set_allocated:google.protobuf.Any.value)
|
||||
}
|
||||
|
||||
#ifdef __GNUC__
|
||||
#pragma GCC diagnostic pop
|
||||
#endif // __GNUC__
|
||||
|
||||
// @@protoc_insertion_point(namespace_scope)
|
||||
|
||||
PROTOBUF_NAMESPACE_CLOSE
|
||||
|
||||
// @@protoc_insertion_point(global_scope)
|
||||
|
||||
#include <google/protobuf/port_undef.inc>
|
||||
#endif // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_google_2fprotobuf_2fany_2eproto
|
||||
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in New Issue